-I$(top_srcdir) \
-I$(top_builddir)/gdk \
-DGTK_DISABLE_COMPAT_H \
+ -DGTK_DISABLE_DEPRECATED \
@GTK_DEBUG_FLAGS@ \
@GTK_XIM_FLAGS@ \
@GTK_LOCALE_FLAGS@ \
-I$(top_srcdir) \
-I$(top_builddir)/gdk \
-DGTK_DISABLE_COMPAT_H \
+ -DGTK_DISABLE_DEPRECATED \
@GTK_DEBUG_FLAGS@ \
@GTK_XIM_FLAGS@ \
@GTK_LOCALE_FLAGS@ \
gtk_container_add(GTK_CONTAINER(window), vbox);
drawing_area = gtk_drawing_area_new();
- gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area),
- gdk_pixbuf_get_width (pixbuf),
- gdk_pixbuf_get_height (pixbuf));
+ gtk_widget_set_usize(GTK_WIDGET(drawing_area),
+ gdk_pixbuf_get_width (pixbuf),
+ gdk_pixbuf_get_height (pixbuf));
gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event",
GTK_SIGNAL_FUNC(expose_cb), NULL);
drawing_area = gtk_drawing_area_new ();
temp_box = gtk_hbox_new (FALSE, 0);
- gtk_drawing_area_size (GTK_DRAWING_AREA(drawing_area), w, h);
+ gtk_widget_set_usize (GTK_WIDGET(drawing_area), w, h);
gtk_box_pack_start (GTK_BOX (temp_box), drawing_area, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), temp_box, FALSE, FALSE, 0);
+2001-02-01 Havoc Pennington <hp@redhat.com>
+
+ * gtk/gtk-sections.txt: updated
+
+ * gtk/gtk-docs.sgml: Move the below from "Deprecated" section to
+ "special-purpose" section; move GtkItem out of deprecated section,
+ since GtkMenuItem uses it, though probably the GtkItem signals
+ should just migrate down to GtkMenuItem someday it won't happen
+ for 2.0
+
+ * gtk/tmpl/gtkgamma.sgml: add note about eventual removal
+
+ * gtk/tmpl/gtkcurve.sgml: add note about eventual removal
+
+ * gtk/tmpl/gtkruler.sgml: add note about eventual removal
+
+ * gtk/tmpl/gtkhruler.sgml: add note about eventual removal
+
+ * gtk/tmpl/gtkvruler.sgml: add note about eventual removal
+
+ * gtk/tmpl/gtkinputdialog.sgml: add note about eventual removal
+
2001-01-30 Havoc Pennington <hp@pobox.com>
Also committed a bunch of automatic changes made by gtk-doc,
<title>Abstract Base Classes</title>
&GtkBin;
&GtkBox;
+ &GtkButtonBox;
&GtkContainer;
>k-GtkEditable;
&GtkOldEditable;
- &GtkButtonBox;
+ &GtkItem;
&GtkMisc;
&GtkObject;
&GtkPaned;
&GtkSocket;
</sect1>
+ <sect1 id="SpecialObjects">
+ <title>Special-purpose features</title>
+ &GtkCurve;
+ &GtkGammaCurve;
+ &GtkHRuler;
+ &GtkRuler;
+ &GtkVRuler;
+ </sect1>
+
<sect1 id="DeprecatedObjects">
<title>Deprecated</title>
&GtkCList;
&GtkCTree;
- &GtkCurve;
&GtkData;
- &GtkGammaCurve;
- &GtkHRuler;
- &GtkItem;
&GtkList;
&GtkListItem;
&GtkPacker;
&GtkPixmap;
- &GtkPreview;
&GtkProgress;
- &GtkRuler;
+ &GtkPreview;
&GtkText;
&GtkTipsQuery;
&GtkTree;
&GtkTreeItem;
- &GtkVRuler;
</sect1>
</chapter>
<FILE>gtklabel</FILE>
<TITLE>GtkLabel</TITLE>
GtkLabel
-GtkLabelWord
gtk_label_new
gtk_label_set_text
gtk_label_set_attributes
<FILE>gtkstatusbar</FILE>
<TITLE>GtkStatusbar</TITLE>
GtkStatusbar
-GtkStatusbarMsg
gtk_statusbar_new
gtk_statusbar_get_context_id
gtk_statusbar_push
gtk_tree_store_set_column_type
gtk_tree_store_set_cell
gtk_tree_store_set
-gtk_tree_store_setv
gtk_tree_store_get
-gtk_tree_store_getv
gtk_tree_store_remove
gtk_tree_store_insert
gtk_tree_store_insert_before
gtk_tree_store_insert_after
gtk_tree_store_prepend
gtk_tree_store_append
-gtk_tree_store_get_root_iter
gtk_tree_store_is_ancestor
gtk_tree_store_iter_depth
<SUBSECTION Standard>
gtk_tree_view_column_set_visible
gtk_tree_view_column_get_visible
gtk_tree_view_column_set_sizing
-gtk_tree_view_column_get_col_type
-gtk_tree_view_column_get_size
+gtk_tree_view_column_get_sizing
+gtk_tree_view_column_get_width
gtk_tree_view_column_set_width
gtk_tree_view_column_set_min_width
gtk_tree_view_column_get_min_width
gtk_tree_view_column_get_max_width
gtk_tree_view_column_set_title
gtk_tree_view_column_get_title
-gtk_tree_view_column_set_header_clickable
+gtk_tree_view_column_set_clickable
gtk_tree_view_column_set_widget
gtk_tree_view_column_get_widget
gtk_tree_view_column_set_justification
gtk_tree_view_remove_column
gtk_tree_view_insert_column
gtk_tree_view_get_column
-gtk_tree_view_move_to
+gtk_tree_view_scroll_to_cell
gtk_tree_view_get_path_at_pos
gtk_tree_view_expand_all
gtk_tree_view_collapse_all
<SUBSECTION Standard>
GTK_TREE_MODEL_SIMPLE
GTK_IS_TREE_MODEL_SIMPLE
-GTK_TYPE_MODEL_SIMPLE
+GTK_TYPE_TREE_MODEL_SIMPLE
gtk_tree_model_simple_get_type
GTK_TREE_MODEL_SIMPLE_CLASS
GTK_IS_TREE_MODEL_SIMPLE_CLASS
gtk_widget_create_pango_context
gtk_widget_get_pango_context
gtk_widget_create_pango_layout
-gtk_widget_render_stock_icon
+gtk_widget_render_icon
gtk_widget_pop_composite_child
gtk_widget_push_composite_child
gtk_widget_queue_clear
</para>
+<!-- ##### STRUCT GtkStatusbarMsg ##### -->
+<para>
+Holds the data for a statusbar message. <structfield>text</structfield> holds the actual text string. <structfield>context_id</structfield> is the context that this message is associated with, and <structfield>message_id</structfield> is this particular message's identifier. However, these fields should not be modified directly.
+</para>
+
+@text:
+@context_id:
+@message_id:
+
+<!-- ##### FUNCTION gtk_widget_render_stock_icon ##### -->
+<para>
+
+</para>
+
+@widget:
+@stock_id:
+@size:
+@detail:
+@Returns:
+
<!-- ##### SECTION ./tmpl/gtkprivate.sgml:Title ##### -->
Private Information
</para>
+<!-- ##### STRUCT GtkLabelWord ##### -->
+<para>\r
+Internal to #GtkLabel.\r
+</para>
+
+
<!-- ##### FUNCTION gtk_text_buffer_spew ##### -->
<para>
allows direct editing of a curve.
<!-- ##### SECTION Long_Description ##### -->
+<para>
+ NOTE this widget is considered too specialized/little-used for
+ GTK+, and will in the future be moved to some other package. If
+ your application needs this widget, feel free to use it, as the
+ widget does work and is useful in some applications; it's just not
+ of general interest. However, we are not accepting new features for
+ the widget, and it will eventually move out of the GTK+
+ distribution.
+</para>
<para>
The #GtkCurve widget allows the user to edit a curve covering a range of
values. It is typically used to fine-tune color balances in graphics
a subclass of #GtkCurve for editing gamma curves.
<!-- ##### SECTION Long_Description ##### -->
+<para>
+ NOTE this widget is considered too specialized/little-used for
+ GTK+, and will in the future be moved to some other package. If
+ your application needs this widget, feel free to use it, as the
+ widget does work and is useful in some applications; it's just not
+ of general interest. However, we are not accepting new features for
+ the widget, and it will eventually move out of the GTK+
+ distribution.
+</para>
<para>
The #GtkGammaCurve widget is a subclass of #GtkCurve specifically for
editing gamma curves, which are used in graphics applications such as the
A horizontal ruler.
<!-- ##### SECTION Long_Description ##### -->
+<para>
+ NOTE this widget is considered too specialized/little-used for
+ GTK+, and will in the future be moved to some other package. If
+ your application needs this widget, feel free to use it, as the
+ widget does work and is useful in some applications; it's just not
+ of general interest. However, we are not accepting new features for
+ the widget, and it will eventually move out of the GTK+
+ distribution.
+</para>
<para>
The HRuler widget is a widget arranged horizontally creating a ruler that is
utilized around other widgets such as a text widget. The ruler is used to show
<!-- ##### SECTION Short_Description ##### -->
+Manipulating stock icons
<!-- ##### SECTION Long_Description ##### -->
<para>
+ An icon factory manages a collection of #GtkIconSet; a #GtkIconSet manages a
+ set of variants of a particular icon (i.e. a #GtkIconSet contains variants for
+ different sizes and widget states). Icons in an icon factory are named by a
+ stock ID, which is a simple string identifying the icon. Each #GtkStyle has a
+ list of #GtkIconFactory derived from the current theme; those icon factories
+ are consulted first when searching for an icon. If the theme doesn't set a
+ particular icon, GTK+ looks for the icon in a list of default icon factories,
+ maintained by gtk_icon_factory_add_default() and
+ gtk_icon_factory_remove_default(). Applications with icons should add a default
+ icon factory with their icons, which will allow themes to override the icons
+ for the application.
+</para>
+<para>
+To display an icon, always use gtk_style_lookup_icon_set() on the widget that
+will display the icon, or the convenience function
+gtk_widget_render_icon(). These functions take the theme into account when
+looking up the icon to use for a given stock ID.
</para>
<!-- ##### SECTION See_Also ##### -->
Configure devices for the XInput extension.
<!-- ##### SECTION Long_Description ##### -->
+<para>
+ NOTE this widget is considered too specialized/little-used for
+ GTK+, and will in the future be moved to some other package. If
+ your application needs this widget, feel free to use it, as the
+ widget does work and is useful in some applications; it's just not
+ of general interest. However, we are not accepting new features for
+ the widget, and it will eventually move out of the GTK+
+ distribution.
+</para>
+
<para>
#GtkInputDialog displays a dialog which allows the user
to configure XInput extension devices. For each
</para>
-<!-- ##### STRUCT GtkLabelWord ##### -->
-<para>\r
-Internal to #GtkLabel.\r
-</para>
-
-
<!-- ##### FUNCTION gtk_label_new ##### -->
<para>\r
Creates a new label with the given string of text inside it. You can\r
Base class for horizontal or vertical rulers
<!-- ##### SECTION Long_Description ##### -->
+<para>
+ NOTE this widget is considered too specialized/little-used for
+ GTK+, and will in the future be moved to some other package. If
+ your application needs this widget, feel free to use it, as the
+ widget does work and is useful in some applications; it's just not
+ of general interest. However, we are not accepting new features for
+ the widget, and it will eventually move out of the GTK+
+ distribution.
+</para>
<para>
The GTKRuler widget is a base class for horizontal and vertical rulers. Rulers
are used to show the mouse pointer's location in a window. The ruler can either
</para>
-<!-- ##### STRUCT GtkStatusbarMsg ##### -->
-<para>
-Holds the data for a statusbar message. <structfield>text</structfield> holds the actual text string. <structfield>context_id</structfield> is the context that this message is associated with, and <structfield>message_id</structfield> is this particular message's identifier. However, these fields should not be modified directly.
-</para>
-
-@text:
-@context_id:
-@message_id:
-
<!-- ##### FUNCTION gtk_statusbar_new ##### -->
<para>
Creates a new #GtkStatusbar ready for messages.
</para>
-@item:
+@items:
@n_items:
+<!-- # Unused Parameters # -->
+@item:
<!-- ##### FUNCTION gtk_stock_add_static ##### -->
</para>
-@item:
+@items:
@n_items:
+<!-- # Unused Parameters # -->
+@item:
<!-- ##### FUNCTION gtk_stock_item_copy ##### -->
@buffer:
@tag:
+@start:
+@end:
+<!-- # Unused Parameters # -->
@start_index:
@end_index:
@buffer:
@tag:
+@start:
+@end:
+<!-- # Unused Parameters # -->
@start_index:
@end_index:
@buffer:
@name:
+@start:
+@end:
+<!-- # Unused Parameters # -->
@start_index:
@end_index:
@buffer:
@name:
+@start:
+@end:
+<!-- # Unused Parameters # -->
@start_index:
@end_index:
@Returns:
+<!-- ##### FUNCTION gtk_tree_view_scroll_to_cell ##### -->
+<para>
+
+</para>
+
+@tree_view:
+@path:
+@column:
+@row_align:
+@col_align:
+
+
<!-- ##### FUNCTION gtk_tree_view_get_path_at_pos ##### -->
<para>
@type:
+<!-- ##### FUNCTION gtk_tree_view_column_get_sizing ##### -->
+<para>
+
+</para>
+
+@tree_column:
+@Returns:
+
+
+<!-- ##### FUNCTION gtk_tree_view_column_get_width ##### -->
+<para>
+
+</para>
+
+@tree_column:
+@Returns:
+
+
<!-- ##### FUNCTION gtk_tree_view_column_set_width ##### -->
<para>
@Returns:
+<!-- ##### FUNCTION gtk_tree_view_column_set_clickable ##### -->
+<para>
+
+</para>
+
+@tree_column:
+@active:
+
+
<!-- ##### FUNCTION gtk_tree_view_column_set_widget ##### -->
<para>
A vertical ruler.
<!-- ##### SECTION Long_Description ##### -->
+<para>
+ NOTE this widget is considered too specialized/little-used for
+ GTK+, and will in the future be moved to some other package. If
+ your application needs this widget, feel free to use it, as the
+ widget does work and is useful in some applications; it's just not
+ of general interest. However, we are not accepting new features for
+ the widget, and it will eventually move out of the GTK+
+ distribution.
+</para>
<para>
The VRuler widget is a widget arranged vertically creating a ruler that is
utilized around other widgets such as a text widget. The ruler is used to show
@Returns:
-<!-- ##### FUNCTION gtk_widget_render_stock_icon ##### -->
+<!-- ##### FUNCTION gtk_widget_render_icon ##### -->
<para>
</para>
}
}
+/**
+ * gtk_cell_renderer_get_size:
+ * @cell: a #GtkCellRenderer
+ * @widget: the widget the renderer is rendering to
+ * @width: location to return width needed to render a cell, or %NULL
+ * @height: location to return height needed to render a cell, or %NULL
+ *
+ * Obtains the width and height needed to render the cell. Used by
+ * view widgets to determine the appropriate size for the cell_area
+ * passed to gtk_cell_renderer_render().
+ **/
void
gtk_cell_renderer_get_size (GtkCellRenderer *cell,
GtkWidget *widget,
gint *width,
gint *height)
{
- /* It's actually okay to pass in a NULL cell, as we run into that
- * a lot
- */
- if (cell == NULL)
- return;
g_return_if_fail (GTK_IS_CELL_RENDERER (cell));
g_return_if_fail (GTK_CELL_RENDERER_GET_CLASS (cell)->get_size != NULL);
flags);
}
+/**
+ * gtk_cell_renderer_event:
+ * @cell: a #GtkCellRenderer
+ * @event: a #GdkEvent
+ * @widget: widget that received the event
+ * @path: widget-dependent string representation of the event location; e.g. for #GtkTreeView, a string representation of #GtkTreePath
+ * @background_area: background area as passed to gtk_cell_renderer_render()
+ * @cell_area: cell area as passed to gtk_cell_renderer_render()
+ * @flags: render flags
+ *
+ * Passes an event to the cell renderer for possible processing. Some
+ * cell renderers may use events; for example, #GtkCellRendererToggle
+ * toggles when it gets a mouse click.
+ *
+ * Return value: %TRUE if the event was consumed/handled
+ **/
gint
gtk_cell_renderer_event (GtkCellRenderer *cell,
GdkEvent *event,
}
}
+/**
+ * gtk_cell_renderer_pixbuf_new:
+ *
+ * Creates a new #GtkCellRendererPixbuf. Adjust rendering
+ * parameters using object properties. Object properties can be set
+ * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
+ * can bind a property to a value in a #GtkTreeModel. For example, you
+ * can bind the "pixbuf" property on the cell renderer to a pixbuf value
+ * in the model, thus rendering a different image in each row of the
+ * #GtkTreeView.
+ *
+ * Return value: the new cell renderer
+ **/
GtkCellRenderer *
gtk_cell_renderer_pixbuf_new (void)
{
}
}
+/**
+ * gtk_cell_renderer_text_new:
+ *
+ * Creates a new #GtkCellRendererText. Adjust how text is drawn using
+ * object properties. Object properties can be
+ * set globally (with g_object_set()). Also, with #GtkTreeViewColumn,
+ * you can bind a property to a value in a #GtkTreeModel. For example,
+ * you can bind the "text" property on the cell renderer to a string
+ * value in the model, thus rendering a different string in each row
+ * of the #GtkTreeView
+ *
+ * Return value: the new cell renderer
+ **/
GtkCellRenderer *
gtk_cell_renderer_text_new (void)
{
}
}
-
static void
gtk_cell_renderer_text_pixbuf_set_property (GObject *object,
guint param_id,
}
}
+/**
+ * gtk_cell_renderer_text_pixbuf_new:
+ *
+ * Creates a new #GtkCellRendererTextPixbuf. Adjust rendering
+ * parameters using object properties. Object properties can be set
+ * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
+ * can bind a property to a value in a #GtkTreeModel. For example, you
+ * can bind the "text" property on the cell renderer to a string value
+ * in the model, thus rendering a different string in each row of the
+ * #GtkTreeView
+ *
+ * Return value: the new cell renderer
+ **/
GtkCellRenderer *
gtk_cell_renderer_text_pixbuf_new (void)
{
switch (param_id)
{
case PROP_ACTIVE:
- gtk_cell_renderer_toggle_set_active (celltoggle, g_value_get_boolean (value));
+ celltoggle->active = g_value_get_boolean (value);
break;
case PROP_RADIO:
celltoggle->radio = g_value_get_boolean (value);
}
}
+/**
+ * gtk_cell_renderer_toggle_new:
+ *
+ * Creates a new #GtkCellRendererToggle. Adjust rendering
+ * parameters using object properties. Object properties can be set
+ * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
+ * can bind a property to a value in a #GtkTreeModel. For example, you
+ * can bind the "active" property on the cell renderer to a boolean value
+ * in the model, thus causing the check button to reflect the state of
+ * the model.
+ *
+ * Return value: the new cell renderer
+ **/
GtkCellRenderer *
gtk_cell_renderer_toggle_new (void)
{
return retval;
}
+/**
+ * gtk_cell_renderer_toggle_set_radio:
+ * @toggle: a #GtkCellRendererToggle
+ * @radio: %TRUE to make the toggle look like a radio button
+ *
+ * If @radio is %TRUE, the cell renderer renders a radio toggle
+ * (i.e. a toggle in a group of mutually-exclusive toggles).
+ * If %FALSE, it renders a check toggle (a standalone boolean option).
+ * This can be set globally for the cell renderer, or changed just
+ * before rendering each cell in the model (for #GtkTreeView, you set
+ * up a per-row setting using #GtkTreeViewColumn to associate model
+ * columns with cell renderer properties).
+ **/
void
gtk_cell_renderer_toggle_set_radio (GtkCellRendererToggle *toggle,
gboolean radio)
{
- g_return_if_fail (toggle != NULL);
g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
toggle->radio = radio;
}
+/**
+ * gtk_cell_renderer_toggle_get_radio:
+ * @toggle: a #GtkCellRendererToggle
+ *
+ * Return value: %TRUE if we're rendering radio toggles rather than checkboxes
+ **/
gboolean
-gtk_cell_renderer_toggle_get_active (GtkCellRendererToggle *toggle)
+gtk_cell_renderer_toggle_get_radio (GtkCellRendererToggle *toggle)
{
g_return_val_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle), FALSE);
- return toggle->active;
-}
-
-void
-gtk_cell_renderer_toggle_set_active (GtkCellRendererToggle *toggle,
- gboolean setting)
-{
- g_return_if_fail (GTK_IS_CELL_RENDERER_TOGGLE (toggle));
-
- setting = !! setting;
-
- if (toggle->active != setting)
- {
- toggle->active = setting;
- g_object_notify (G_OBJECT (toggle), "active");
- }
+ return toggle->radio;
}
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_CLIST_H__
#define __GTK_CLIST_H__
#endif /* __cplusplus */
#endif /* __GTK_CLIST_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
}
}
+/**
+ * gtk_container_set_border_width:
+ * @container: a #GtkContainer
+ * @border_width: amount of blank space to leave <emphasis>outside</emphasis> the container
+ *
+ * The border width of a container is the amount of space to leave
+ * around the outside of the container. The only exception to this is
+ * #GtkWindow; because toplevel windows can't leave space outside,
+ * they leave the space inside. The border is added on all sides of
+ * the container. To add space to only one side, one approach is to
+ * create a #GtkAlignment widget, call gtk_widget_set_usize() to give
+ * it a size, and place it on the side of the container as a spacer.
+ *
+ **/
void
gtk_container_set_border_width (GtkContainer *container,
guint border_width)
}
}
+/**
+ * gtk_container_add:
+ * @container: a #GtkContainer
+ * @widget: a widget to be placed inside @container
+ *
+ * Adds @widget to @container. Typically used for simple containers
+ * such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated
+ * layout containers such as #GtkBox or #GtkTable, this function will
+ * pick default packing parameters that may not be correct. So
+ * consider functions such as gtk_box_pack_start() and
+ * gtk_table_attach() as an alternative to gtk_container_add() in
+ * those cases. A widget may be added to only one container at a time;
+ * you can't place the same widget inside two different containers.
+ **/
void
gtk_container_add (GtkContainer *container,
GtkWidget *widget)
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (widget->parent == NULL);
+
+ if (widget->parent != NULL)
+ {
+ g_warning ("Attempting to add a widget with type %s to a container of "
+ "type %s, but the widget is already inside a container of type %s",
+ g_type_name (G_TYPE_FROM_INSTANCE (widget)),
+ g_type_name (G_TYPE_FROM_INSTANCE (container)),
+ g_type_name (G_TYPE_FROM_INSTANCE (widget->parent)));
+ return;
+ }
gtk_signal_emit (GTK_OBJECT (container), container_signals[ADD], widget);
}
+/**
+ * gtk_container_remove:
+ * @container: a #GtkContainer
+ * @widget: a current child of @container
+ *
+ * Removes @widget from @container. @widget must be inside @container.
+ * Note that @container will own a reference to @widget, and that this
+ * may be the last reference held; so removing a widget from its
+ * container can destroy that widget. If you want to use @widget
+ * again, you need to add a reference to it while it's not inside
+ * a container, using g_object_ref().
+ **/
void
gtk_container_remove (GtkContainer *container,
GtkWidget *widget)
g_slist_free (resize_containers);
}
+/**
+ * gtk_container_forall:
+ * @container: a #GtkContainer
+ * @callback: a callback
+ * @callback_data: callback user data
+ *
+ * Invokes @callback on each child of @container, including children
+ * that are considered "internal" (implementation details of the
+ * container). "Internal" children generally weren't added by the user
+ * of the container, but were added by the container implementation
+ * itself. Most applications should use gtk_container_foreach(),
+ * rather than gtk_container_forall().
+ **/
void
gtk_container_forall (GtkContainer *container,
GtkCallback callback,
class->forall (container, TRUE, callback, callback_data);
}
+/**
+ * gtk_container_foreach:
+ * @container: a #GtkContainer
+ * @callback: a callback
+ * @callback_data: callback user data
+ *
+ * Invokes @callback on each non-internal child of @container. See
+ * gtk_container_forall() for details on what constitutes an
+ * "internal" child. Most applications should use
+ * gtk_container_foreach(), rather than gtk_container_forall().
+ **/
void
gtk_container_foreach (GtkContainer *container,
GtkCallback callback,
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_CTREE_H__
#define __GTK_CTREE_H__
#endif /* __cplusplus */
#endif /* __GTK_CTREE_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+/*
+ * NOTE this widget is considered too specialized/little-used for
+ * GTK+, and will in the future be moved to some other package. If
+ * your application needs this widget, feel free to use it, as the
+ * widget does work and is useful in some applications; it's just not
+ * of general interest. However, we are not accepting new features for
+ * the widget, and it will eventually move out of the GTK+
+ * distribution.
+ */
+
#ifndef __GTK_CURVE_H__
#define __GTK_CURVE_H__
GtkType gtk_drawing_area_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_drawing_area_new (void);
+
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_drawing_area_size (GtkDrawingArea *darea,
gint width,
gint height);
+#endif /* GTK_DISABLE_DEPRECATED */
#ifdef __cplusplus
gtk_entry_recompute (entry);
}
+/**
+ * gtk_entry_set_invisible_char:
+ * @entry: a #GtkEntry
+ * @ch: a Unicode character
+ *
+ * Sets the character to use in place of the actual text when
+ * gtk_entry_set_visibility() has been called to set text visibility
+ * to %FALSE. i.e. this is the character used in "password mode" to
+ * show the user how many characters have been typed. The default
+ * invisible char is an asterisk ('*'). If you set the invisible char
+ * to 0, then the user will get no feedback at all; there will be
+ * no text on the screen as they type.
+ *
+ **/
void
gtk_entry_set_invisible_char (GtkEntry *entry,
gunichar ch)
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+/*
+ * NOTE this widget is considered too specialized/little-used for
+ * GTK+, and will in the future be moved to some other package. If
+ * your application needs this widget, feel free to use it, as the
+ * widget does work and is useful in some applications; it's just not
+ * of general interest. However, we are not accepting new features for
+ * the widget, and it will eventually move out of the GTK+
+ * distribution.
+ */
+
#ifndef __GTK_GAMMA_CURVE_H__
#define __GTK_GAMMA_CURVE_H__
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+/*
+ * NOTE this widget is considered too specialized/little-used for
+ * GTK+, and will in the future be moved to some other package. If
+ * your application needs this widget, feel free to use it, as the
+ * widget does work and is useful in some applications; it's just not
+ * of general interest. However, we are not accepting new features for
+ * the widget, and it will eventually move out of the GTK+
+ * distribution.
+ */
+
#ifndef __GTK_HRULER_H__
#define __GTK_HRULER_H__
G_OBJECT_CLASS (parent_class)->finalize (object);
}
+/**
+ * gtk_icon_factory_new:
+ *
+ * Creates a new #GtkIconFactory. An icon factory manages a collection
+ * of #GtkIconSet; a #GtkIconSet manages a set of variants of a
+ * particular icon (i.e. a #GtkIconSet contains variants for different
+ * sizes and widget states). Icons in an icon factory are named by a
+ * stock ID, which is a simple string identifying the icon. Each
+ * #GtkStyle has a list of #GtkIconFactory derived from the current
+ * theme; those icon factories are consulted first when searching for
+ * an icon. If the theme doesn't set a particular icon, GTK+ looks for
+ * the icon in a list of default icon factories, maintained by
+ * gtk_icon_factory_add_default() and
+ * gtk_icon_factory_remove_default(). Applications with icons should
+ * add a default icon factory with their icons, which will allow
+ * themes to override the icons for the application.
+ *
+ * Return value: a new #GtkIconFactory
+ **/
GtkIconFactory*
gtk_icon_factory_new (void)
{
return GTK_ICON_FACTORY (g_object_new (GTK_TYPE_ICON_FACTORY, NULL));
}
+/**
+ * gtk_icon_factory_add:
+ * @factory: a #GtkIconFactory
+ * @stock_id: icon name
+ * @icon_set: icon set
+ *
+ * Adds the given @icon_set to the icon factory, under the name
+ * @stock_id. @stock_id should be namespaced for your application,
+ * e.g. "myapp-whatever-icon". Normally applications create a
+ * #GtkIconFactory, then add it to the list of default factories with
+ * gtk_icon_factory_add_default(). Then they pass the @stock_id to
+ * widgets such as #GtkImage to display the icon. Themes can provide
+ * an icon with the same name (such as "myapp-whatever-icon") to
+ * override your application's default icons. If an icon already
+ * existed in @factory for @stock_id, it is unreferenced and replaced
+ * with the new @icon_set.
+ *
+ **/
void
gtk_icon_factory_add (GtkIconFactory *factory,
const gchar *stock_id,
gtk_icon_set_unref (old_value);
}
+/**
+ * gtk_icon_factory_lookup:
+ * @factory: a #GtkIconFactory
+ * @stock_id: an icon name
+ *
+ * Looks up @stock_id in the icon factory, returning an icon set
+ * if found, otherwise %NULL. For display to the user, you should
+ * use gtk_style_lookup_icon_set() on the #GtkStyle for the
+ * widget that will display the icon, instead of using this
+ * function directly, so that themes are taken into account.
+ *
+ * Return value: icon set of @stock_id.
+ **/
GtkIconSet *
gtk_icon_factory_lookup (GtkIconFactory *factory,
const gchar *stock_id)
static GtkIconFactory *gtk_default_icons = NULL;
static GSList *default_factories = NULL;
+/**
+ * gtk_icon_factory_add_default:
+ * @factory: a #GtkIconFactory
+ *
+ * Adds an icon factory to the list of icon factories searched by
+ * gtk_style_lookup_icon_set(). This means that, for example,
+ * gtk_image_new_from_stock() will be able to find icons in @factory.
+ * There will normally be an icon factory added for each library or
+ * application that comes with icons. The default icon factories
+ * can be overridden by themes.
+ *
+ **/
void
gtk_icon_factory_add_default (GtkIconFactory *factory)
{
default_factories = g_slist_prepend (default_factories, factory);
}
+/**
+ * gtk_icon_factory_remove_default:
+ * @factory: a #GtkIconFactory previously added with gtk_icon_factory_add_default()
+ *
+ * Removes an icon factory from the list of default icon
+ * factories. Not normally used; you might use it for a library that
+ * can be unloaded or shut down.
+ *
+ **/
void
gtk_icon_factory_remove_default (GtkIconFactory *factory)
{
g_object_unref (G_OBJECT (factory));
}
+/**
+ * gtk_icon_factory_lookup_default:
+ * @stock_id: an icon name
+ *
+ * Looks for an icon in the list of default icon factories. For
+ * display to the user, you should use gtk_style_lookup_icon_set() on
+ * the #GtkStyle for the widget that will display the icon, instead of
+ * using this function directly, so that themes are taken into
+ * account.
+ *
+ *
+ * Return value: a #GtkIconSet, or %NULL
+ **/
GtkIconSet *
gtk_icon_factory_lookup_default (const gchar *stock_id)
{
}
}
+/**
+ * gtk_icon_size_lookup:
+ * @alias: name of an icon size
+ * @width: location to store icon width
+ * @height: location to store icon height
+ *
+ * Obtains the pixel size of an icon, normally @alias would be
+ * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc. This function
+ * isn't normally needed, gtk_widget_render_icon() is the usual
+ * way to get an icon for rendering, then just look at the size of
+ * the rendered pixbuf. The rendered pixbuf may not even correspond to
+ * the width/height returned by gtk_icon_size_lookup(), because themes
+ * are free to render the pixbuf however they like.
+ *
+ * Return value: %TRUE if @alias was known.
+ **/
gboolean
gtk_icon_size_lookup (const gchar *alias,
gint *widthp,
return TRUE;
}
+/**
+ * gtk_icon_size_register:
+ * @alias: name of the icon size
+ * @width: the icon width
+ * @height: the icon height
+ *
+ * Registers a new icon size, along the same lines as #GTK_ICON_SIZE_MENU,
+ * etc.
+ *
+ **/
void
gtk_icon_size_register (const gchar *alias,
gint width,
icon_size_add (alias, width, height);
}
+/**
+ * gtk_icon_size_register_alias:
+ * @alias: an alias for @target
+ * @target: an existing icon size name
+ *
+ * Registers @alias as another name for @target, usable when calling
+ * gtk_icon_size_lookup().
+ *
+ **/
void
gtk_icon_size_register_alias (const gchar *alias,
const gchar *target)
static guint cache_serial = 0;
+/**
+ * gtk_icon_set_new:
+ *
+ * Creates a new #GtkIconSet. A #GtkIconSet represents a single icon
+ * in various sizes and widget states. It can provide a #GdkPixbuf
+ * for a given size and state on request, and automatically caches
+ * some of the rendered #GdkPixbuf objects.
+ *
+ * Normally you would use gtk_widget_render_icon() instead of
+ * using #GtkIconSet directly. The one case where you'd use
+ * #GtkIconSet is to create application-specific icon sets to place in
+ * a #GtkIconFactory.
+ *
+ * Return value: a new #GtkIconSet
+ **/
GtkIconSet*
gtk_icon_set_new (void)
{
return icon_set;
}
+/**
+ * gtk_icon_set_ref:
+ * @icon_set: a #GtkIconSet
+ *
+ * Increments the reference count on @icon_set
+ *
+ * Return value: @icon_set is returned
+ **/
GtkIconSet*
gtk_icon_set_ref (GtkIconSet *icon_set)
{
return icon_set;
}
+/**
+ * gtk_icon_set_unref:
+ * @icon_set: a #GtkIconSet
+ *
+ * Decrements the reference count on @icon_set, and frees memory
+ * if the reference count reaches 0.
+ **/
void
gtk_icon_set_unref (GtkIconSet *icon_set)
{
}
}
+/**
+ * gtk_icon_set_copy:
+ * @icon_set: a #GtkIconSet
+ *
+ * Copies @icon_set by value.
+ *
+ * Return value: a new #GtkIconSet identical to the first.
+ **/
GtkIconSet*
gtk_icon_set_copy (GtkIconSet *icon_set)
{
return source;
}
+/**
+ * gtk_icon_set_render_icon:
+ * @icon_set: a #GtkIconSet
+ * @style: a #GtkStyle associated with @widget, or %NULL
+ * @direction: text direction
+ * @state: widget state
+ * @size: icon size
+ * @widget: widget that will display the icon, or %NULL
+ * @detail: detail to pass to the theme engine, or %NULL
+ *
+ * Renders an icon using gtk_style_render_icon(). In most cases,
+ * gtk_widget_render_icon() is better, since it automatically
+ * provides most of the arguments from the current widget settings.
+ * A %NULL return value is possible if an icon file fails to load
+ * or the like.
+ *
+ * Return value: a #GdkPixbuf to be displayed, or %NULL
+ **/
GdkPixbuf*
gtk_icon_set_render_icon (GtkIconSet *icon_set,
GtkStyle *style,
return 0;
}
+/**
+ * gtk_icon_set_add_source:
+ * @icon_set: a #GtkIconSet
+ * @source: a #GtkIconSource
+ *
+ * Icon sets have a list of #GtkIconSource, which they use as base
+ * icons for rendering icons in different states and sizes. Icons are
+ * scaled, made to look insensitive, etc. in
+ * gtk_icon_set_render_icon(), but #GtkIconSet needs base images to
+ * work with. The base images and when to use them are described by
+ * #GtkIconSource.
+ *
+ **/
void
gtk_icon_set_add_source (GtkIconSet *icon_set,
const GtkIconSource *source)
icon_source_compare);
}
-GtkIconSource *
+/**
+ * gtk_icon_source_copy:
+ * @source: a #GtkIconSource
+ *
+ * Creates a copy of @source; mostly useful for language bindings.
+ *
+ * Return value: a new #GtkIconSource
+ **/
+GtkIconSource*
gtk_icon_source_copy (const GtkIconSource *source)
{
GtkIconSource *copy;
return copy;
}
+/**
+ * gtk_icon_source_free:
+ * @source: a #GtkIconSource
+ *
+ * Frees a dynamically-allocated icon source, along with its
+ * filename, size, and pixbuf fields if those are not %NULL.
+ **/
void
gtk_icon_source_free (GtkIconSource *source)
{
}
+/**
+ * gtk_image_new_from_pixmap:
+ * @pixmap: a #GdkPixmap, or %NULL
+ * @mask: a #GdkBitmap, or %NULL
+ *
+ * Creates a #GtkImage widget displaying @pixmap with a @mask.
+ * A #GdkImage is a server-side image buffer in the pixel format of the
+ * current display. The #GtkImage does not assume a reference to the
+ * pixmap or mask; you still need to unref them if you own references.
+ * #GtkImage will add its own reference rather than adopting yours.
+ *
+ * Return value: a new #GtkImage
+ **/
GtkWidget*
gtk_image_new_from_pixmap (GdkPixmap *pixmap,
GdkBitmap *mask)
return GTK_WIDGET (image);
}
+/**
+ * gtk_image_new_from_image:
+ * @image: a #GdkImage, or %NULL
+ * @mask: a #GdkBitmap, or %NULL
+ *
+ * Creates a #GtkImage widget displaying a @image with a @mask.
+ * A #GdkImage is a client-side image buffer in the pixel format of the
+ * current display.
+ * The #GtkImage does not assume a reference to the
+ * image or mask; you still need to unref them if you own references.
+ * #GtkImage will add its own reference rather than adopting yours.
+ *
+ * Return value: a new #GtkImage
+ **/
GtkWidget*
gtk_image_new_from_image (GdkImage *gdk_image,
GdkBitmap *mask)
return GTK_WIDGET (image);
}
+/**
+ * gtk_image_new_from_file:
+ * @filename: a filename
+ *
+ * Creates a new #GtkImage displaying the file @filename. If the
+ * file isn't found or can't be loaded, the #GtkImage will display
+ * a "broken image" icon. If you need to detect failures to load
+ * the file, use gdk_pixbuf_new_from_file() to load the file yourself,
+ * then create the #GtkImage from the pixbuf.
+ *
+ * Return value: a new #GtkImage
+ **/
GtkWidget*
gtk_image_new_from_file (const gchar *filename)
{
return GTK_WIDGET (image);
}
+/**
+ * gtk_image_new_from_pixbuf:
+ * @pixbuf: a #GdkPixbuf, or %NULL
+ *
+ * Creates a new #GtkImage displaying @pixbuf.
+ * The #GtkImage does not assume a reference to the
+ * pixbuf; you still need to unref it if you own references.
+ * #GtkImage will add its own reference rather than adopting yours.
+ *
+ * Return value: a new #GtkImage
+ **/
GtkWidget*
gtk_image_new_from_pixbuf (GdkPixbuf *pixbuf)
{
return GTK_WIDGET (image);
}
+/**
+ * gtk_image_new_from_stock:
+ * @stock_id: a stock icon name
+ * @size: a stock icon size
+ *
+ * Creates a #GtkImage displaying a stock icon. Sample stock icon
+ * names are #GTK_STOCK_ICON_OPEN, #GTK_STOCK_ICON_EXIT. Sample stock sizes
+ * are #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. If the stock
+ * icon name isn't known, a "broken image" icon will be displayed instead.
+ *
+ * Return value: a new #GtkImage displaying the stock icon
+ **/
GtkWidget*
gtk_image_new_from_stock (const gchar *stock_id,
const gchar *size)
return GTK_WIDGET (image);
}
+/**
+ * gtk_image_new_from_icon_set:
+ * @icon_set: a #GtkIconSet
+ * @size: a stock icon size
+ *
+ * Creates a #GtkImage displaying an icon set. Sample stock sizes are
+ * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_SMALL_TOOLBAR. Instead of using
+ * this function, usually it's better to create a #GtkIconFactory, put
+ * your icon sets in the icon factory, add the icon factory to the
+ * list of default factories with gtk_icon_factory_add_default(), and
+ * then use gtk_image_new_from_stock(). This will allow themes to
+ * override the icon you ship with your application.
+ *
+ * The #GtkImage does not assume a reference to the
+ * icon set; you still need to unref it if you own references.
+ * #GtkImage will add its own reference rather than adopting yours.
+ *
+ *
+ * Return value: a new #GtkImage
+ **/
GtkWidget*
gtk_image_new_from_icon_set (GtkIconSet *icon_set,
const gchar *size)
return GTK_WIDGET (image);
}
+/**
+ * gtk_image_set_from_pixmap:
+ * @image: a #GtkImage
+ * @pixmap: a #GdkPixmap or %NULL
+ * @mask: a #GdkBitmap or %NULL
+ *
+ * See gtk_image_new_from_pixmap() for details.
+ *
+ **/
void
gtk_image_set_from_pixmap (GtkImage *image,
GdkPixmap *pixmap,
}
}
+/**
+ * gtk_image_set_from_image:
+ * @image: a #GtkImage
+ * @gdk_image: a #GdkImage or %NULL
+ * @mask: a #GdkBitmap or %NULL
+ *
+ * See gtk_image_new_from_image() for details.
+ *
+ **/
void
gtk_image_set_from_image (GtkImage *image,
GdkImage *gdk_image,
}
}
+/**
+ * gtk_image_set_from_file:
+ * @image: a #GtkImage
+ * @filename: a filename or %NULL
+ *
+ * See gtk_image_new_from_file() for details.
+ *
+ **/
void
gtk_image_set_from_file (GtkImage *image,
const gchar *filename)
g_object_unref (G_OBJECT (pixbuf));
}
+/**
+ * gtk_image_set_from_pixbuf:
+ * @image: a #GtkImage
+ * @pixbuf: a #GdkPixbuf or %NULL
+ *
+ * See gtk_image_new_from_pixbuf() for details.
+ *
+ **/
void
gtk_image_set_from_pixbuf (GtkImage *image,
GdkPixbuf *pixbuf)
}
}
+/**
+ * gtk_image_set_from_stock:
+ * @image: a #GtkImage
+ * @stock_id: a stock icon name
+ * @size: a stock icon size
+ *
+ * See gtk_image_new_from_stock for details.
+ *
+ **/
void
gtk_image_set_from_stock (GtkImage *image,
const gchar *stock_id,
}
}
+/**
+ * gtk_image_set_from_icon_set:
+ * @image: a #GtkImage
+ * @icon_set: a #GtkIconSet
+ * @size: a stock icon size
+ *
+ * See gtk_image_new_from_icon_set() for details.
+ *
+ **/
void
gtk_image_set_from_icon_set (GtkImage *image,
GtkIconSet *icon_set,
}
}
+/**
+ * gtk_image_get_storage_type:
+ * @image: a #GtkImage
+ *
+ * Gets the type of representation being used by the #GtkImage
+ * to store image data. If the #GtkImage has no image data,
+ * the return value will be %GTK_IMAGE_EMPTY.
+ *
+ * Return value: image representation being used
+ **/
GtkImageType
gtk_image_get_storage_type (GtkImage *image)
{
return image->storage_type;
}
+/**
+ * gtk_image_get_pixmap:
+ * @image: a #GtkImage
+ * @pixmap: location to store the pixmap, or %NULL
+ * @mask: location to store the mask, or %NULL
+ *
+ * Gets the pixmap and mask being displayed by the #GtkImage.
+ * The storage type of the image must be %GTK_IMAGE_EMPTY or
+ * %GTK_IMAGE_PIXMAP (see gtk_image_get_storage_type()).
+ * The caller of this function does not own a reference to the
+ * returned pixmap and mask.
+ *
+ **/
void
gtk_image_get_pixmap (GtkImage *image,
GdkPixmap **pixmap,
*mask = image->data.pixmap.mask;
}
+/**
+ * gtk_image_get_image:
+ * @image: a #GtkImage
+ * @gdk_image: return location for a #GtkImage
+ * @mask: return location for a #GdkBitmap
+ *
+ * Gets the #GdkImage and mask being displayed by the #GtkImage.
+ * The storage type of the image must be %GTK_IMAGE_EMPTY or
+ * %GTK_IMAGE_IMAGE (see gtk_image_get_storage_type()).
+ * The caller of this function does not own a reference to the
+ * returned image and mask.
+ **/
void
gtk_image_get_image (GtkImage *image,
GdkImage **gdk_image,
*mask = image->data.image.mask;
}
+/**
+ * gtk_image_get_pixbuf:
+ * @image: a #GtkImage
+ *
+ *
+ * Gets the #GdkPixbuf being displayed by the #GtkImage.
+ * The storage type of the image must be %GTK_IMAGE_EMPTY or
+ * %GTK_IMAGE_PIXBUF (see gtk_image_get_storage_type()).
+ * The caller of this function does not own a reference to the
+ * returned pixbuf.
+ *
+ * Return value: the displayed pixbuf, or %NULL if the image is empty
+ **/
GdkPixbuf*
gtk_image_get_pixbuf (GtkImage *image)
{
return image->data.pixbuf.pixbuf;
}
+/**
+ * gtk_image_get_stock:
+ * @image: a #GtkImage
+ * @stock_id: place to store a stock icon name
+ * @size: place to store a stock icon size
+ *
+ * Gets the stock icon name and size being displayed by the #GtkImage.
+ * The storage type of the image must be %GTK_IMAGE_EMPTY or
+ * %GTK_IMAGE_STOCK (see gtk_image_get_storage_type()).
+ * The returned strings are owned by the #GtkImage and should not
+ * be freed.
+ *
+ **/
void
gtk_image_get_stock (GtkImage *image,
gchar **stock_id,
image->data.stock.stock_id = NULL;
if (stock_id)
- *stock_id = g_strdup (image->data.stock.stock_id);
+ *stock_id = image->data.stock.stock_id;
if (size)
*size = image->data.stock.size;
}
+/**
+ * gtk_image_get_icon_set:
+ * @image: a #GtkImage
+ * @icon_set: location to store a #GtkIconSet
+ * @size: location to store a stock icon size
+ *
+ * Gets the icon set and size being displayed by the #GtkImage.
+ * The storage type of the image must be %GTK_IMAGE_EMPTY or
+ * %GTK_IMAGE_ICON_SET (see gtk_image_get_storage_type()).
+ * The returned size string is owned by the #GtkImage and should not
+ * be freed.
+ *
+ **/
void
gtk_image_get_icon_set (GtkImage *image,
GtkIconSet **icon_set,
*icon_set = image->data.icon_set.icon_set;
if (size)
- *size = g_strdup (image->data.icon_set.size);
+ *size = image->data.icon_set.size;
}
GtkWidget*
break;
case GTK_IMAGE_STOCK:
- stock_pixbuf = gtk_widget_render_stock_icon (widget,
- image->data.stock.stock_id,
- image->data.stock.size,
- NULL);
+ stock_pixbuf = gtk_widget_render_icon (widget,
+ image->data.stock.stock_id,
+ image->data.stock.size,
+ NULL);
if (stock_pixbuf)
{
image_bound.width = gdk_pixbuf_get_width (stock_pixbuf);
switch (image->storage_type)
{
case GTK_IMAGE_STOCK:
- pixbuf = gtk_widget_render_stock_icon (GTK_WIDGET (image),
- image->data.stock.stock_id,
- image->data.stock.size,
- NULL);
+ pixbuf = gtk_widget_render_icon (GTK_WIDGET (image),
+ image->data.stock.stock_id,
+ image->data.stock.size,
+ NULL);
break;
case GTK_IMAGE_ICON_SET:
gchar **size);
-
+#ifndef GTK_DISABLE_DEPRECATED
/* These three are deprecated */
GtkWidget* gtk_image_new (GdkImage *val,
void gtk_image_get (GtkImage *image,
GdkImage **val,
GdkBitmap **mask);
-
+#endif /* GTK_DISABLE_DEPRECATED */
#ifdef __cplusplus
}
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+/*
+ * NOTE this widget is considered too specialized/little-used for
+ * GTK+, and will in the future be moved to some other package. If
+ * your application needs this widget, feel free to use it, as the
+ * widget does work and is useful in some applications; it's just not
+ * of general interest. However, we are not accepting new features for
+ * the widget, and it will eventually move out of the GTK+
+ * distribution.
+ */
+
#ifndef __GTK_INPUTDIALOG_H__
#define __GTK_INPUTDIALOG_H__
}
/**
- * gtk_label_set_markup:
+ * gtk_label_set_markup_with_accel:
* @label: a #GtkLabel
* @str: a markup string (see <link linkend="PangoMarkupFormat">Pango markup format</link>)
*
* indicating that they represent a keyboard accelerator, and the GDK
* keyval for the first underlined accelerator is returned. If there are
* no underlines in the text, GDK_VoidSymbol will be returned.
+ *
+ * Return value: GDK keyval for accelerator
**/
guint
gtk_label_set_markup_with_accel (GtkLabel *label,
typedef struct _GtkLabel GtkLabel;
typedef struct _GtkLabelClass GtkLabelClass;
-typedef struct _GtkLabelWord GtkLabelWord;
-
struct _GtkLabel
{
GtkMisc misc;
# define gtk_label_set gtk_label_set_text
#endif /* GTK_DISABLE_COMPAT_H */
+#ifndef GTK_DISABLE_DEPRECATED
/* Deprecated */
void gtk_label_get (GtkLabel *label,
char **str);
+#endif /* GTK_DISABLE_DEPRECATED */
#ifdef __cplusplus
}
void gtk_layout_set_vadjustment (GtkLayout *layout,
GtkAdjustment *adjustment);
+
+#ifndef GTK_DISABLE_DEPRECATED
/* These disable and enable moving and repainting the scrolling window
* of the GtkLayout, respectively. If you want to update the layout's
* offsets but do not want it to repaint itself, you should use these
*/
void gtk_layout_freeze (GtkLayout *layout);
void gtk_layout_thaw (GtkLayout *layout);
+#endif /* GTK_DISABLE_DEPRECATED */
#ifdef __cplusplus
}
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_LIST_H__
#define __GTK_LIST_H__
#endif /* __GTK_LIST_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
list_store->length = 0;
}
+/**
+ * gtk_list_store_new:
+ *
+ * Creates a new #GtkListStore. A #GtkListStore implements the
+ * #GtkTreeModel interface, and stores a linked list of
+ * rows; each row can have any number of columns. Columns are of uniform type,
+ * i.e. all cells in a column have the same type such as #G_TYPE_STRING or
+ * #GDK_TYPE_PIXBUF. Use #GtkListStore to store data to be displayed in a
+ * #GtkTreeView.
+ *
+ * Return value: a new #GtkListStore
+ **/
GtkListStore *
gtk_list_store_new (void)
{
return GTK_LIST_STORE (gtk_type_new (gtk_list_store_get_type ()));
}
+/**
+ * gtk_list_store_new_with_types:
+ * @n_columns: number of columns in the list store
+ * @Varargs: pairs of column number and #GType
+ *
+ * Creates a new list store as with gtk_list_store_new(),
+ * simultaneously setting up the columns and column types as with
+ * gtk_list_store_set_n_columns() and
+ * gtk_list_store_set_column_type().
+ *
+ *
+ * Return value: a new #GtkListStore
+ **/
GtkListStore *
gtk_list_store_new_with_types (gint n_columns,
...)
return retval;
}
+/**
+ * gtk_list_store_set_n_columns:
+ * @store: a #GtkListStore
+ * @n_columns: number of columns
+ *
+ * Sets the number of columns in the #GtkListStore.
+ *
+ **/
void
gtk_list_store_set_n_columns (GtkListStore *list_store,
gint n_columns)
list_store->n_columns = n_columns;
}
+/**
+ * gtk_list_store_set_column_type:
+ * @store: a #GtkListStore
+ * @column: column number
+ * @type: type of the data stored in @column
+ *
+ * Supported types include: %G_TYPE_UINT, %G_TYPE_INT, %G_TYPE_UCHAR,
+ * %G_TYPE_CHAR, %G_TYPE_BOOLEAN, %G_TYPE_POINTER, %G_TYPE_FLOAT, %G_TYPE_STRING,
+ * %G_TYPE_OBJECT, and %G_TYPE_BOXED, along with subclasses of those types such
+ * as %GDK_TYPE_PIXBUF.
+ *
+ **/
void
gtk_list_store_set_column_type (GtkListStore *list_store,
gint column,
/* This is a somewhat inelegant function that does a lot of list
* manipulations on it's own.
*/
+
+/**
+ * gtk_list_store_set_cell:
+ * @store: a #GtkListStore
+ * @iter: iterator for the row you're modifying
+ * @column: column number to modify
+ * @value: new value for the cell
+ *
+ * Sets the data in the cell specified by @iter and @column.
+ * The type of @value must be convertible to the type of the
+ * column.
+ *
+ **/
void
gtk_list_store_set_cell (GtkListStore *list_store,
GtkTreeIter *iter,
NULL, iter);
}
+/**
+ * gtk_list_store_set_valist:
+ * @list_store: a #GtkListStore
+ * @iter: row to set data for
+ * @var_args: va_list of column/value pairs
+ *
+ * See gtk_list_store_set(); this version takes a va_list for
+ * use by language bindings.
+ *
+ **/
void
gtk_list_store_set_valist (GtkListStore *list_store,
GtkTreeIter *iter,
- va_list var_args)
+ va_list var_args)
{
gint column;
*
* Sets the value of one or more cells in the row referenced by @iter.
* The variable argument list should contain integer column numbers,
- * each column number followed by the value to be set. For example,
+ * each column number followed by the value to be set.
* The list is terminated by a -1. For example, to set column 0 with type
* %G_TYPE_STRING to "Foo", you would write gtk_list_store_set (store, iter,
* 0, "Foo", -1).
va_end (var_args);
}
+/**
+ * gtk_list_store_get_valist:
+ * @list_store: a #GtkListStore
+ * @iter: a row in @list_store
+ * @var_args: va_list of column/return location pairs
+ *
+ * See gtk_list_store_get(), this version takes a va_list for
+ * language bindings to use.
+ *
+ **/
void
gtk_list_store_get_valist (GtkListStore *list_store,
GtkTreeIter *iter,
}
}
+/**
+ * gtk_list_store_get:
+ * @list_store: a #GtkListStore
+ * @iter: a row in @list_store
+ * @Varargs: pairs of column number and value return locations, terminated by -1
+ *
+ * Gets the value of one or more cells in the row referenced by @iter.
+ * The variable argument list should contain integer column numbers,
+ * each column number followed by a place to store the value being
+ * retrieved. The list is terminated by a -1. For example, to get a
+ * value from column 0 with type %G_TYPE_STRING, you would
+ * write: gtk_list_store_set (store, iter, 0, &place_string_here, -1),
+ * where place_string_here is a gchar* to be filled with the string.
+ * If appropriate, the returned values have to be freed or unreferenced.
+ *
+ **/
void
gtk_list_store_get (GtkListStore *list_store,
GtkTreeIter *iter,
list_store->stamp ++;
}
+/**
+ * gtk_list_store_remove:
+ * @store: a #GtkListStore
+ * @iter: a row in @list_store
+ *
+ * Removes the given row from the list store, emitting the
+ * "deleted" signal on #GtkTreeModel.
+ *
+ **/
void
gtk_list_store_remove (GtkListStore *list_store,
GtkTreeIter *iter)
list_store->length += 1;
}
+/**
+ * gtk_list_store_insert:
+ * @store: a #GtkListStore
+ * @iter: iterator to initialize with the new row
+ * @position: position to insert the new row
+ *
+ * Creates a new row at @position, initializing @iter to point to the
+ * new row, and emitting the "inserted" signal from the #GtkTreeModel
+ * interface.
+ *
+ **/
void
gtk_list_store_insert (GtkListStore *list_store,
GtkTreeIter *iter,
gtk_tree_path_free (path);
}
+/**
+ * gtk_list_store_insert_before:
+ * @store: a #GtkListStore
+ * @iter: iterator to initialize with the new row
+ * @sibling: an existing row
+ *
+ * Inserts a new row before @sibling, initializing @iter to point to
+ * the new row, and emitting the "inserted" signal from the
+ * #GtkTreeModel interface.
+ *
+ **/
void
gtk_list_store_insert_before (GtkListStore *list_store,
GtkTreeIter *iter,
gtk_tree_path_free (path);
}
+/**
+ * gtk_list_store_insert_after:
+ * @store: a #GtkListStore
+ * @iter: iterator to initialize with the new row
+ * @sibling: an existing row
+ *
+ * Inserts a new row after @sibling, initializing @iter to point to
+ * the new row, and emitting the "inserted" signal from the
+ * #GtkTreeModel interface.
+ *
+ **/
void
gtk_list_store_insert_after (GtkListStore *list_store,
GtkTreeIter *iter,
gtk_tree_path_free (path);
}
+/**
+ * gtk_list_store_prepend:
+ * @store: a #GtkListStore
+ * @iter: iterator to initialize with new row
+ *
+ * Prepends a row to @store, initializing @iter to point to the
+ * new row, and emitting the "inserted" signal on the #GtkTreeModel
+ * interface for the @store.
+ *
+ **/
void
gtk_list_store_prepend (GtkListStore *list_store,
GtkTreeIter *iter)
gtk_tree_path_free (path);
}
+/**
+ * gtk_list_store_append:
+ * @store: a #GtkListStore
+ * @iter: iterator to initialize with the new row
+ *
+ * Appends a row to @store, initializing @iter to point to the
+ * new row, and emitting the "inserted" signal on the #GtkTreeModel
+ * interface for the @store.
+ *
+ **/
void
gtk_list_store_append (GtkListStore *list_store,
GtkTreeIter *iter)
return gdk_set_locale ();
}
+/**
+ * gtk_get_default_language:
+ *
+ * Returns the ISO language code for the default language currently in
+ * effect. (Note that this can change over the life of an
+ * application.) The default language is derived from the current
+ * locale. It determines, for example, whether GTK+ uses the
+ * right-to-left or left-to-right text direction.
+ *
+ * Return value: the default language as an allocated string, must be freed
+ **/
gchar*
gtk_get_default_language (void)
{
closure->marshal (NULL, closure->data, 2, args);
}
+/**
+ * gtk_get_current_event:
+ *
+ * Obtains a copy of the event currently being processed by GTK+. For
+ * example, if you get a "clicked" signal from #GtkButton, the current
+ * event will be the #GdkEventButton that triggered the "clicked"
+ * signal. The returned event must be freed with gdk_event_free().
+ * If there is no current event, the function returns %NULL.
+ *
+ * Return value: a copy of the current event, or %NULL if no current event.
+ **/
GdkEvent*
gtk_get_current_event (void)
{
return GDK_CURRENT_TIME;
}
+/**
+ * gtk_get_current_event_state:
+ * @state: a location to store the state of the current event
+ *
+ * If there is a current event and it has a state field, place
+ * that state field in @state and return %TRUE, otherwise return
+ * %FALSE.
+ *
+ * Return value: %TRUE if there was a current event and it had a state field
+ **/
gboolean
gtk_get_current_event_state (GdkModifierType *state)
{
}
}
+/**
+ * gtk_get_event_widget:
+ * @event: a #GdkEvent
+ *
+ * If @event is %NULL or the event was not associated with any widget,
+ * returns %NULL, otherwise returns the widget that received the event
+ * originally.
+ *
+ * Return value: the widget that originally received @event, or %NULL
+ **/
GtkWidget*
gtk_get_event_widget (GdkEvent *event)
{
}
}
+/**
+ * gtk_propagate_event:
+ * @widget: a #GtkWidget
+ * @event: an event
+ *
+ * Sends an event to a widget, propagating the event to parent widgets
+ * if the event remains unhandled. Events received by GTK+ from GDK
+ * normally begin in gtk_main_do_event(). Depending on the type of
+ * event, existence of modal dialogs, grabs, etc., the event may be
+ * propagated; if so, this function is used. gtk_propagate_event()
+ * calls gtk_widget_event() on each widget it decides to send the
+ * event to. So gtk_widget_event() is the lowest-level function; it
+ * simply emits the "event" and possibly an event-specific signal on a
+ * widget. gtk_propagate_event() is a bit higher-level, and
+ * gtk_main_do_event() is the highest level.
+ *
+ * All that said, you most likely don't want to use any of these
+ * functions; synthesizing events is rarely needed. Consider asking on
+ * the mailing list for better ways to achieve your goals. For
+ * example, use gdk_window_invalidate_rect() or
+ * gtk_widget_queue_draw() instead of making up expose events.
+ *
+ **/
void
gtk_propagate_event (GtkWidget *widget,
GdkEvent *event)
#endif
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_exit (gint error_code);
+#endif /* GTK_DISABLE_DEPRECATED */
gchar* gtk_set_locale (void);
gchar* gtk_get_default_language (void);
gint gtk_events_pending (void);
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_OLD_EDITABLE_H__
#define __GTK_OLD_EDITABLE_H__
#endif /* __GTK_OLD_EDITABLE_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
}
}
+/**
+ * gtk_option_menu_get_history:
+ * @option_menu: a #GtkOptionMenu
+ *
+ * Retrieves the index of the currently selected menu item. The menu
+ * items are numbered from top to bottom, starting with 0.
+ *
+ * Return value: index of the selected menu item, or -1 if there are no menu items
+ **/
gint
gtk_option_menu_get_history (GtkOptionMenu *option_menu)
{
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_PACKER_H__
#define __GTK_PACKER_H__
#endif /* __GTK_PACKER_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
(*callback) (paned->child2, callback_data);
}
+/**
+ * gtk_paned_get_position:
+ * @paned: a #GtkPaned widget
+ *
+ * Obtains the position of the divider between the two panes.
+ *
+ * Return value: position of the divider
+ **/
gint
gtk_paned_get_position (GtkPaned *paned)
{
return paned->child1_size;
}
+/**
+ * gtk_paned_set_position:
+ * @paned: a #GtkPaned widget
+ * @position: pixel position of divider
+ *
+ * Sets the position of the divider between the two panes.
+ **/
void
gtk_paned_set_position (GtkPaned *paned,
gint position)
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_PIXMAP_H__
#define __GTK_PIXMAP_H__
#endif /* __GTK_PIXMAP_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTK_PREVIEW_H__
#define __GTK_PREVIEW_H__
#endif /* __GTK_PREVIEW_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
extern "C" {
#endif /* __cplusplus */
+#ifndef GTK_DISABLE_DEPRECATED
#define GTK_TYPE_PROGRESS (gtk_progress_get_type ())
#define GTK_PROGRESS(obj) (GTK_CHECK_CAST ((obj), GTK_TYPE_PROGRESS, GtkProgress))
#define GTK_IS_PROGRESS_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS))
#define GTK_PROGRESS_GET_CLASS(obj) (GTK_CHECK_GET_CLASS ((obj), GTK_TYPE_PROGRESS, GtkProgressClass))
+#endif /* GTK_DISABLE_DEPRECATED */
typedef struct _GtkProgress GtkProgress;
typedef struct _GtkProgressClass GtkProgressClass;
* directly.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
GtkType gtk_progress_get_type (void) G_GNUC_CONST;
void gtk_progress_set_show_text (GtkProgress *progress,
gint show_text);
gfloat gtk_progress_get_percentage_from_value (GtkProgress *progress,
gfloat value);
+#endif /* GTK_DISABLE_DEPRECATED */
#ifdef __cplusplus
}
* rest deprecated. However, the changes are 100% backward-compatible and
* should break no existing code.
*
- * The following 5 functions are the new programming interface.
+ * The following 9 functions are the new programming interface.
*/
void gtk_progress_bar_pulse (GtkProgressBar *pbar);
void gtk_progress_bar_set_text (GtkProgressBar *pbar,
GtkProgressBarOrientation gtk_progress_bar_get_orientation (GtkProgressBar *pbar);
+#ifndef GTK_DISABLE_DEPRECATED
+
/* Everything below here is deprecated */
GtkWidget* gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment);
void gtk_progress_bar_set_bar_style (GtkProgressBar *pbar,
void gtk_progress_bar_update (GtkProgressBar *pbar,
gfloat percentage);
+#endif /* GTK_DISABLE_DEPRECATED */
+
#ifdef __cplusplus
}
#endif /* __cplusplus */
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+/*
+ * NOTE this widget is considered too specialized/little-used for
+ * GTK+, and will in the future be moved to some other package. If
+ * your application needs this widget, feel free to use it, as the
+ * widget does work and is useful in some applications; it's just not
+ * of general interest. However, we are not accepting new features for
+ * the widget, and it will eventually move out of the GTK+
+ * distribution.
+ */
+
#ifndef __GTK_RULER_H__
#define __GTK_RULER_H__
}
}
+/**
+ * gtk_scrolled_window_set_shadow_type:
+ * @scrolled_window: a #GtkScrolledWindow
+ * @type: kind of shadow to draw around scrolled window contents
+ *
+ * Changes the type of shadow drawn around the contents of
+ * @scrolled_window.
+ *
+ **/
void
gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,
GtkShadowType type)
#include "gtksignal.h"
#include "gtkstatusbar.h"
+typedef struct _GtkStatusbarMsg GtkStatusbarMsg;
+
+struct _GtkStatusbarMsg
+{
+ gchar *text;
+ guint context_id;
+ guint message_id;
+};
enum
{
typedef struct _GtkStatusbar GtkStatusbar;
typedef struct _GtkStatusbarClass GtkStatusbarClass;
-typedef struct _GtkStatusbarMsg GtkStatusbarMsg;
struct _GtkStatusbar
{
const gchar *text);
};
-struct _GtkStatusbarMsg
-{
- gchar *text;
- guint context_id;
- guint message_id;
-};
GtkType gtk_statusbar_get_type (void) G_GNUC_CONST;
GtkWidget* gtk_statusbar_new (void);
}
}
+/**
+ * gtk_stock_add:
+ * @items: a #GtkStockItem or array of items
+ * @n_items: number of #GtkStockItem in @items
+ *
+ * Registers each of the stock items in @items. If an item already
+ * exists with the same stock ID as one of the @items, the old item
+ * gets replaced. The stock items are copied, so GTK+ does not hold
+ * any pointer into @items and @items can be freed. Use
+ * gtk_stock_add_static() if @items is persistent and GTK+ need not
+ * copy the array.
+ *
+ **/
void
gtk_stock_add (const GtkStockItem *items,
guint n_items)
real_add (items, n_items, TRUE);
}
+/**
+ * gtk_stock_add_static:
+ * @items: a #GtkStockItem or array of #GtkStockItem
+ * @n_items: number of items
+ *
+ * Same as gtk_stock_add(), but doesn't copy @items, so
+ * @items must persist until application exit.
+ *
+ **/
void
gtk_stock_add_static (const GtkStockItem *items,
guint n_items)
real_add (items, n_items, FALSE);
}
+/**
+ * gtk_stock_lookup:
+ * @stock_id: a stock item name
+ * @item: stock item to initialize with values
+ *
+ * Fills @item with the registered values for @stock_id, returning %TRUE
+ * if @stock_id was known.
+ *
+ *
+ * Return value: %TRUE if @item was initialized
+ **/
gboolean
gtk_stock_lookup (const gchar *stock_id,
GtkStockItem *item)
return list;
}
+/**
+ * gtk_stock_list_items:
+ *
+ * Retrieves a list of all known #GtkStockItem. The items are not copied;
+ * they should not be freed. However, the list itself must be freed
+ * with g_slist_free().
+ *
+ * Return value: a list of registered stock items
+ **/
GSList *
gtk_stock_list_items (void)
{
return g_hash_table_get_values (stock_hash);
}
+/**
+ * gtk_stock_item_copy:
+ * @item: a #GtkStockItem
+ *
+ * Copies a stock item, mostly useful for language bindings and not in applications.
+ *
+ * Return value: a new #GtkStockItem
+ **/
GtkStockItem *
gtk_stock_item_copy (const GtkStockItem *item)
{
return copy;
}
+/**
+ * gtk_stock_item_free:
+ * @item: a #GtkStockItem
+ *
+ * Frees a stock item allocated on the heap, such as one returned by
+ * gtk_stock_item_copy(). Also frees the fields inside the stock item,
+ * if they are not %NULL.
+ *
+ **/
void
gtk_stock_item_free (GtkStockItem *item)
{
gchar *translation_domain;
};
-void gtk_stock_add (const GtkStockItem *item,
+void gtk_stock_add (const GtkStockItem *items,
guint n_items);
-void gtk_stock_add_static (const GtkStockItem *item,
+void gtk_stock_add_static (const GtkStockItem *items,
guint n_items);
gboolean gtk_stock_lookup (const gchar *stock_id,
GtkStockItem *item);
gint y,
gint width,
gint height);
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_draw_string (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
gint x,
gint y,
const gchar *string);
+#endif /* GTK_DISABLE_DEPRECATED */
void gtk_draw_box (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
gint y,
gint width,
gint height);
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_paint_string (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
gint x,
gint y,
const gchar *string);
+#endif /* GTK_DISABLE_DEPRECATED */
void gtk_paint_box (GtkStyle *style,
GdkWindow *window,
GtkStateType state_type,
return seg ? seg->body.mark.obj : NULL;
}
+/**
+ * gtk_text_mark_set_visible:
+ * @mark: a #GtkTextMark
+ * @setting: visibility of mark
+ *
+ * Sets the visibility of @mark; the insertion point is normally
+ * visible, i.e. you can see it as a vertical bar. Also, the text
+ * widget uses a visible mark to indicate where a drop will occur when
+ * dragging-and-dropping text. Most other marks are not visible.
+ * Marks are not visible by default.
+ *
+ **/
void
gtk_text_mark_set_visible (GtkTextMark *mark,
gboolean setting)
g_signal_emit (G_OBJECT (buffer), signals[CHANGED], 0);
}
+/**
+ * gtk_text_buffer_insert_pixbuf:
+ * @buffer: a #GtkTextBuffer
+ * @iter: location to insert the pixbuf
+ * @pixbuf: a #GdkPixbuf
+ *
+ * Inserts an image into the text buffer at @iter. The image will be
+ * counted as one character in character counts, and when obtaining
+ * the buffer contents as a string, will be represented by the Unicode
+ * "object replacement character" 0xFFFC. Note that the "slice"
+ * variants for obtaining portions of the buffer as a string include
+ * this character for pixbufs, but the "text" variants do
+ * not. e.g. see gtk_text_buffer_get_slice() and
+ * gtk_text_buffer_get_text().
+ *
+ **/
void
gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer,
GtkTextIter *iter,
}
+/**
+ * gtk_text_buffer_apply_tag:
+ * @buffer: a #GtkTextBuffer
+ * @tag: a #GtkTextTag
+ * @start: one bound of range to be tagged
+ * @end: other bound of range to be tagged
+ *
+ * Emits the "apply_tag" signal on @buffer. The default
+ * handler for the signal applies @tag to the given range.
+ * @start and @end do not have to be in order.
+ *
+ **/
void
gtk_text_buffer_apply_tag (GtkTextBuffer *buffer,
GtkTextTag *tag,
gtk_text_buffer_emit_tag (buffer, tag, TRUE, start, end);
}
+/**
+ * gtk_text_buffer_remove_tag:
+ * @buffer: a #GtkTextBuffer
+ * @tag: a #GtkTextTag
+ * @start: one bound of range to be untagged
+ * @end: other bound of range to be untagged
+ *
+ * Emits the "remove_tag" signal. The default handler for the signal
+ * removes all occurrences of @tag from the given range. @start and
+ * @end don't have to be in order.
+ *
+ **/
void
gtk_text_buffer_remove_tag (GtkTextBuffer *buffer,
GtkTextTag *tag,
}
+/**
+ * gtk_text_buffer_apply_tag_by_name:
+ * @buffer: a #GtkTextBuffer
+ * @name: name of a named #GtkTextTag
+ * @start: one bound of range to be tagged
+ * @end: other bound of range to be tagged
+ *
+ * Calls gtk_text_tag_table_lookup() on the buffer's tag table to
+ * get a #GtkTextTag, then calls gtk_text_buffer_apply_tag().
+ *
+ **/
void
gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
- const gchar *name,
+ const gchar *name,
const GtkTextIter *start,
const GtkTextIter *end)
{
gtk_text_buffer_emit_tag (buffer, tag, TRUE, start, end);
}
+/**
+ * gtk_text_buffer_remove_tag_by_name:
+ * @buffer: a #GtkTextBuffer
+ * @name: name of a #GtkTextTag
+ * @start: one bound of range to be untagged
+ * @end: other bound of range to be untagged
+ *
+ * Calls gtk_text_tag_table_lookup() on the buffer's tag table to
+ * get a #GtkTextTag, then calls gtk_text_buffer_remove_tag().
+ *
+ *
+ **/
void
gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
const gchar *name,
* Obtain various iterators
*/
+/**
+ * gtk_text_buffer_get_iter_at_line_offset:
+ * @buffer: a #GtkTextBuffer
+ * @iter: iterator to initialize
+ * @line_number: line number counting from 0
+ * @char_offset: char offset from start of line
+ *
+ * Obtains an iterator pointing to @char_offset within the given
+ * line. The @char_offset must exist, offsets off the end of the line
+ * are not allowed. Note <emphasis>characters</emphasis>, not bytes;
+ * UTF-8 may encode one character as multiple bytes.
+ *
+ **/
void
gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
GtkTextIter *iter,
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
_gtk_text_btree_get_iter_at_line_char (get_btree (buffer),
- iter, line_number, char_offset);
+ iter, line_number, char_offset);
}
+/**
+ * gtk_text_buffer_get_iter_at_line_index:
+ * @buffer: a #GtkTextBuffer
+ * @iter: iterator to initialize
+ * @line_number: line number counting from 0
+ * @byte_index: byte index from start of line
+ *
+ * Obtains an iterator pointing to @byte_index within the given line.
+ * @byte_index must be the start of a UTF-8 character, and must not be
+ * beyond the end of the line. Note <emphasis>bytes</emphasis>, not
+ * characters; UTF-8 may encode one character as multiple bytes.
+ *
+ **/
void
gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer,
GtkTextIter *iter,
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
_gtk_text_btree_get_iter_at_line_byte (get_btree (buffer),
- iter, line_number, byte_index);
+ iter, line_number, byte_index);
}
+/**
+ * gtk_text_buffer_get_iter_at_line:
+ * @buffer: a #GtkTextBuffer
+ * @iter: iterator to initialize
+ * @line_number: line number counting from 0
+ *
+ * Initializes @iter to the start of the given line.
+ **/
void
gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
GtkTextIter *iter,
gtk_text_buffer_get_iter_at_line_offset (buffer, iter, line_number, 0);
}
+/**
+ * gtk_text_buffer_get_iter_at_offset:
+ * @buffer: a #GtkTextBuffer
+ * @iter: iterator to initialize
+ * @char_offset: char offset from start of buffer, counting from 0
+ *
+ * Initializes @iter to a position @char_offset chars from the start
+ * of the entire buffer.
+ *
+ **/
void
gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
GtkTextIter *iter,
_gtk_text_btree_get_iter_at_char (get_btree (buffer), iter, char_offset);
}
+/**
+ * gtk_text_buffer_get_last_iter:
+ * @buffer: a #GtkTextBuffer
+ * @iter: iterator to initialize
+ *
+ * Initializes @iter with the "end iterator," one past the last valid
+ * character in the text buffer. If dereferenced with
+ * gtk_text_iter_get_char(), the end iterator has a character value of
+ * 0. The entire buffer lies in the range from the first position in
+ * the buffer (call gtk_text_buffer_get_iter_at_offset() to get
+ * character position 0) to the end iterator.
+ *
+ **/
void
gtk_text_buffer_get_last_iter (GtkTextBuffer *buffer,
GtkTextIter *iter)
_gtk_text_btree_get_last_iter (get_btree (buffer), iter);
}
+/**
+ * gtk_text_buffer_get_bounds:
+ * @buffer: a #GtkTextBuffer
+ * @start: iterator to initialize with first position in the buffer
+ * @end: iterator to initialize with the end iterator
+ *
+ * Retrieves the first and last iterators in the buffer, i.e. the
+ * entire buffer lies within the range [@start,@end).
+ *
+ **/
void
gtk_text_buffer_get_bounds (GtkTextBuffer *buffer,
GtkTextIter *start,
* Modified flag
*/
+/**
+ * gtk_text_buffer_modified:
+ * @buffer: a #GtkTextBuffer
+ *
+ * Indicates whether the buffer has been modified since the last call
+ * to gtk_text_buffer_set_modified() set the modification flag to
+ * %FALSE. Used for example to enable a "save" function in a text
+ * editor.
+ *
+ * Return value: %TRUE if the buffer has been modified
+ **/
gboolean
gtk_text_buffer_modified (GtkTextBuffer *buffer)
{
return buffer->modified;
}
+/**
+ * gtk_text_buffer_set_modified:
+ * @buffer: a #GtkTextBuffer
+ * @setting: modification flag setting
+ *
+ * Used to keep track of whether the buffer has been modified since the
+ * last time it was saved. Whenever the buffer is saved to disk, call
+ * gtk_text_buffer_set_modified (@buffer, FALSE). When the buffer is modified,
+ * it will automatically toggled on the modified bit again. When the modified
+ * bit flips, the buffer emits a "modified_changed" signal.
+ *
+ **/
void
gtk_text_buffer_set_modified (GtkTextBuffer *buffer,
gboolean setting)
* Assorted other stuff
*/
+/**
+ * gtk_text_buffer_get_line_count:
+ * @buffer: a #GtkTextBuffer
+ *
+ * Obtains the number of lines in the buffer. This value is cached, so
+ * the function is very fast.
+ *
+ * Return value: number of lines in the buffer
+ **/
gint
gtk_text_buffer_get_line_count (GtkTextBuffer *buffer)
{
return _gtk_text_btree_line_count (get_btree (buffer));
}
+/**
+ * gtk_text_buffer_get_char_count:
+ * @buffer: a #GtkTextBuffer
+ *
+ * Gets the number of characters in the buffer; note that characters
+ * and bytes are not the same, you can't e.g. expect the contents of
+ * the buffer in string form to be this many bytes long. The character
+ * count is cached, so this function is very fast.
+ *
+ * Return value: number of characters in the buffer
+ **/
gint
gtk_text_buffer_get_char_count (GtkTextBuffer *buffer)
{
clipboard_selection_buffer_received, data);
}
+/**
+ * gtk_text_buffer_paste_primary:
+ * @buffer: a #GtkTextBuffer
+ * @override_location: location to insert pasted text, or %NULL for at the cursor
+ * @default_editable: whether the buffer is editable by default
+ *
+ * Pastes the primary selection at the insertion point, or at @override_location.
+ * (Note: pasting is asynchronous, that is, we'll ask for the paste data
+ * and return, and at some point later after the main loop runs, the paste
+ * data will be inserted.)
+ **/
void
gtk_text_buffer_paste_primary (GtkTextBuffer *buffer,
const GtkTextIter *override_location,
paste (buffer, FALSE, TRUE, default_editable);
}
+/**
+ * gtk_text_buffer_paste_clipboard:
+ * @buffer: a #GtkTextBuffer
+ * @default_editable: whether the buffer is editable by default
+ *
+ * Pastes the clipboard contents at the insertion point. (Note:
+ * pasting is asynchronous, that is, we'll ask for the paste data and
+ * return, and at some point later after the main loop runs, the paste
+ * data will be inserted.)
+ *
+ **/
void
gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
gboolean default_editable)
paste (buffer, TRUE, TRUE, default_editable);
}
+/**
+ * gtk_text_buffer_delete_selection:
+ * @buffer: a #GtkTextBuffer
+ * @interactive: whether the deletion is caused by user interaction
+ * @default_editable: whether the buffer is editable by default
+ *
+ * Deletes the range between the "insert" and "selection_bound" marks,
+ * that is, the currently-selected text. If @interactive is %TRUE,
+ * the editability of the selection will be considered (users can't delete
+ * uneditable text).
+ *
+ * Return value: whether there was a non-empty selection to delete
+ **/
gboolean
gtk_text_buffer_delete_selection (GtkTextBuffer *buffer,
gboolean interactive,
}
}
+/**
+ * gtk_text_buffer_cut_clipboard:
+ * @buffer: a #GtkTextBuffer
+ * @default_editable: default editability of the buffer
+ *
+ * Copies the currently-selected text to the clipboard, then deletes
+ * said text if it's editable.
+ *
+ **/
void
gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
gboolean default_editable)
gtk_text_buffer_end_user_action (buffer);
}
+/**
+ * gtk_text_buffer_copy_clipboard:
+ * @buffer: a #GtkTextBuffer
+ *
+ * Copies the currently-selected text to the clipboard.
+ *
+ **/
void
gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer)
{
/**
* gtk_text_buffer_get_selection_bounds:
- * @buffer: a #GtkTextBuffer
+ * @buffer: a #GtkTextBuffer a #GtkTextBuffer
* @start: iterator to initialize with selection start
* @end: iterator to initialize with selection end
*
*
* The "interactive" buffer mutation functions, such as
* gtk_text_buffer_insert_interactive(), automatically call begin/end
- * user action around the buffer operations they perform, so there's no
- * need to add extra calls if you user action consists solely of those
- * functions.
+ * user action around the buffer operations they perform, so there's
+ * no need to add extra calls if you user action consists solely of a
+ * single call to one of those functions.
**/
void
gtk_text_buffer_begin_user_action (GtkTextBuffer *buffer)
/* Tag manipulation */
void gtk_text_buffer_apply_tag (GtkTextBuffer *buffer,
GtkTextTag *tag,
- const GtkTextIter *start_index,
- const GtkTextIter *end_index);
+ const GtkTextIter *start,
+ const GtkTextIter *end);
void gtk_text_buffer_remove_tag (GtkTextBuffer *buffer,
GtkTextTag *tag,
- const GtkTextIter *start_index,
- const GtkTextIter *end_index);
+ const GtkTextIter *start,
+ const GtkTextIter *end);
void gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
const gchar *name,
- const GtkTextIter *start_index,
- const GtkTextIter *end_index);
+ const GtkTextIter *start,
+ const GtkTextIter *end);
void gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
const gchar *name,
- const GtkTextIter *start_index,
- const GtkTextIter *end_index);
+ const GtkTextIter *start,
+ const GtkTextIter *end);
/* You can either ignore the return value, or use it to
iter_set_from_byte_offset (real, line, line_byte_offset);
+ if (real->segment->type == >k_text_char_type &&
+ (real->segment->body.chars[real->segment_byte_offset] & 0xc0) == 0x80)
+ g_warning ("Incorrect line byte index %d falls in the middle of a UTF-8 "
+ "character; this will crash the text buffer. "
+ "Byte indexes must refer to the start of a character.",
+ line_byte_offset);
+
return real;
}
}
}
+/**
+ * gtk_text_iter_forward_word_end:
+ * @iter: a #GtkTextIter
+ *
+ * Moves forward to the next word end. (If @iter is currently on a
+ * word end, moves forward to the next one after that.) Word breaks
+ * are determined by Pango and should be correct for nearly any
+ * language (if not, the correct fix would be to the Pango word break
+ * algorithms).
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_forward_word_end (GtkTextIter *iter)
{
return find_by_log_attrs (iter, find_word_end_func, TRUE, FALSE);
}
+/**
+ * gtk_text_iter_forward_word_end:
+ * @iter: a #GtkTextIter
+ *
+ * Moves backward to the next word start. (If @iter is currently on a
+ * word start, moves backward to the next one after that.) Word breaks
+ * are determined by Pango and should be correct for nearly any
+ * language (if not, the correct fix would be to the Pango word break
+ * algorithms).
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_backward_word_start (GtkTextIter *iter)
{
/* FIXME a loop around a truly slow function means
* a truly spectacularly slow function.
*/
+
+/**
+ * gtk_text_iter_forward_word_ends:
+ * @iter: a #GtkTextIter
+ * @count: number of times to move
+ *
+ * Calls gtk_text_iter_forward_word_end() up to @count times.
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_forward_word_ends (GtkTextIter *iter,
gint count)
return TRUE;
}
+/**
+ * gtk_text_iter_backward_word_starts
+ * @iter: a #GtkTextIter
+ * @count: number of times to move
+ *
+ * Calls gtk_text_iter_backward_word_starts() up to @count times.
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_backward_word_starts (GtkTextIter *iter,
gint count)
return TRUE;
}
+/**
+ * gtk_text_iter_starts_word:
+ * @iter: a #GtkTextIter
+ *
+ * Determines whether @iter begins a natural-language word. Word
+ * breaks are determined by Pango and should be correct for nearly any
+ * language (if not, the correct fix would be to the Pango word break
+ * algorithms).
+ *
+ * Return value: %TRUE if @iter is at the start of a word
+ **/
gboolean
gtk_text_iter_starts_word (const GtkTextIter *iter)
{
return test_log_attrs (iter, is_word_start_func);
}
+/**
+ * gtk_text_iter_ends_word:
+ * @iter: a #GtkTextIter
+ *
+ * Determines whether @iter ends a natural-language word. Word breaks
+ * are determined by Pango and should be correct for nearly any
+ * language (if not, the correct fix would be to the Pango word break
+ * algorithms).
+ *
+ * Return value: %TRUE if @iter is at the end of a word
+ **/
gboolean
gtk_text_iter_ends_word (const GtkTextIter *iter)
{
return test_log_attrs (iter, is_word_end_func);
}
+/**
+ * gtk_text_iter_inside_word:
+ * @iter: a #GtkTextIter
+ *
+ * Determines whether @iter is inside a natural-language word (as
+ * opposed to say inside some whitespace). Word breaks are determined
+ * by Pango and should be correct for nearly any language (if not, the
+ * correct fix would be to the Pango word break algorithms).
+ *
+ * Return value: %TRUE if @iter is inside a word
+ **/
gboolean
gtk_text_iter_inside_word (const GtkTextIter *iter)
{
return test_log_attrs (iter, inside_word_func);
}
+/**
+ * gtk_text_iter_starts_sentence:
+ * @iter: a #GtkTextIter
+ *
+ * Determines whether @iter begins a sentence. Sentence boundaries are
+ * determined by Pango and should be correct for nearly any language
+ * (if not, the correct fix would be to the Pango text boundary
+ * algorithms).
+ *
+ * Return value: %TRUE if @iter is at the start of a sentence.
+ **/
gboolean
gtk_text_iter_starts_sentence (const GtkTextIter *iter)
{
return test_log_attrs (iter, is_sentence_start_func);
}
+/**
+ * gtk_text_iter_ends_sentence:
+ * @iter: a #GtkTextIter
+ *
+ * Determines whether @iter ends a sentence. Sentence boundaries are
+ * determined by Pango and should be correct for nearly any language
+ * (if not, the correct fix would be to the Pango text boundary
+ * algorithms).
+ *
+ * Return value: %TRUE if @iter is at the end of a sentence.
+ **/
gboolean
gtk_text_iter_ends_sentence (const GtkTextIter *iter)
{
return test_log_attrs (iter, is_sentence_end_func);
}
+/**
+ * gtk_text_iter_inside_sentence:
+ * @iter: a #GtkTextIter
+ *
+ * Determines whether @iter is inside a sentence (as opposed to in
+ * between two sentences, e.g. after a period and before the first
+ * letter of the next sentence). Sentence boundaries are determined
+ * by Pango and should be correct for nearly any language (if not, the
+ * correct fix would be to the Pango text boundary algorithms).
+ *
+ * Return value: %TRUE if @iter is inside a sentence.
+ **/
gboolean
gtk_text_iter_inside_sentence (const GtkTextIter *iter)
{
return test_log_attrs (iter, inside_sentence_func);
}
+/**
+ * gtk_text_iter_forward_sentence_end:
+ * @iter: a #GtkTextIter
+ *
+ * Moves forward to the next sentence end. (If @iter is at the end of
+ * a sentence, moves to the next end of sentence.) Sentence
+ * boundaries are determined by Pango and should be correct for nearly
+ * any language (if not, the correct fix would be to the Pango text
+ * boundary algorithms).
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_forward_sentence_end (GtkTextIter *iter)
{
return find_by_log_attrs (iter, find_sentence_end_func, TRUE, FALSE);
}
+/**
+ * gtk_text_iter_backward_sentence_start:
+ * @iter: a #GtkTextIter
+ *
+ * Moves backward to the next sentence start; if @iter is already at
+ * the start of a sentence, moves backward to the next one. Sentence
+ * boundaries are determined by Pango and should be correct for nearly
+ * any language (if not, the correct fix would be to the Pango text
+ * boundary algorithms).
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_backward_sentence_start (GtkTextIter *iter)
{
/* FIXME a loop around a truly slow function means
* a truly spectacularly slow function.
*/
+/**
+ * gtk_text_iter_forward_sentence_ends:
+ * @iter: a #GtkTextIter
+ * @count: number of sentences to move
+ *
+ * Calls gtk_text_iter_forward_sentence_end() up to @count times.
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_forward_sentence_ends (GtkTextIter *iter,
gint count)
return TRUE;
}
+/**
+ * gtk_text_iter_forward_sentence_ends:
+ * @iter: a #GtkTextIter
+ * @count: number of sentences to move
+ *
+ * Calls gtk_text_iter_backward_sentence_start() up to @count times.
+ *
+ * Return value: %TRUE if @iter moved and is not the end iterator
+ **/
gboolean
gtk_text_iter_backward_sentence_starts (GtkTextIter *iter,
gint count)
return attrs[offset].is_cursor_position;
}
+/**
+ * gtk_text_iter_forward_cursor_position:
+ * @iter: a #GtkTextIter
+ *
+ * Moves @iter forward by a single cursor position. Cursor positions
+ * are (unsurprisingly) positions where the cursor can appear. Perhaps
+ * surprisingly, there may not be a cursor position between all
+ * characters. The most common example for European languages would be
+ * a carriage return/newline sequence. For some Unicode characters,
+ * the equivalent of say the letter "a" with an accent mark will be
+ * represented as two characters, first the letter then a "combining
+ * mark" that causes the accent to be rendered; so the cursor can't go
+ * between those two characters. See also the #PangoLogAttr structure and
+ * pango_break() function.
+ *
+ * Return value: %TRUE if we moved and the new position is dereferenceable
+ **/
gboolean
gtk_text_iter_forward_cursor_position (GtkTextIter *iter)
{
return find_by_log_attrs (iter, find_forward_cursor_pos_func, TRUE, FALSE);
}
+/**
+ * gtk_text_iter_backward_cursor_position:
+ * @iter: a #GtkTextIter
+ *
+ * Like gtk_text_iter_forward_cursor_position(), but moves backward.
+ *
+ * Return value: %TRUE if we moved and the new position is dereferenceable
+ **/
gboolean
gtk_text_iter_backward_cursor_position (GtkTextIter *iter)
{
return find_by_log_attrs (iter, find_backward_cursor_pos_func, FALSE, FALSE);
}
+/**
+ * gtk_text_iter_forward_cursor_positions:
+ * @iter: a #GtkTextIter
+ * @count: number of positions to move
+ *
+ * Moves up to @count cursor positions. See
+ * gtk_text_iter_forward_cursor_position() for details.
+ *
+ * Return value: %TRUE if we moved and the new position is dereferenceable
+ **/
gboolean
gtk_text_iter_forward_cursor_positions (GtkTextIter *iter,
gint count)
return TRUE;
}
+/**
+ * gtk_text_iter_backward_cursor_positions:
+ * @iter: a #GtkTextIter
+ * @count: number of positions to move
+ *
+ * Moves up to @count cursor positions. See
+ * gtk_text_iter_forward_cursor_position() for details.
+ *
+ * Return value: %TRUE if we moved and the new position is dereferenceable
+ **/
gboolean
gtk_text_iter_backward_cursor_positions (GtkTextIter *iter,
gint count)
return TRUE;
}
+/**
+ * gtk_text_iter_is_cursor_position:
+ * @iter: a #GtkTextIter
+ *
+ * See gtk_text_iter_forward_cursor_position() or #PangoLogAttr or
+ * pango_break() for details on what a cursor position is.
+ *
+ * Return value: %TRUE if the cursor can be placed at @iter
+ **/
gboolean
gtk_text_iter_is_cursor_position (const GtkTextIter *iter)
{
return test_log_attrs (iter, is_cursor_pos_func);
}
+/**
+ * gtk_text_iter_set_line_offset:
+ * @iter: a #GtkTextIter
+ * @char_on_line: a character offset relative to the start of @iter's current line
+ *
+ * Moves @iter within a line, to a new <emphasis>character</emphasis>
+ * (not byte) offset. The given character offset must be less than or
+ * equal to the number of characters in the line; if equal, @iter
+ * moves to the start of the next line. See
+ * gtk_text_iter_set_line_index() if you have a byte index rather than
+ * a character offset.
+ *
+ **/
void
gtk_text_iter_set_line_offset (GtkTextIter *iter,
gint char_on_line)
check_invariants (iter);
}
+/**
+ * gtk_text_iter_set_line_index:
+ * @iter: a #GtkTextIter
+ * @byte_on_line: a byte index relative to the start of @iter's current line
+ *
+ * Same as gtk_text_iter_set_line_offset(), but works with a
+ * <emphasis>byte</emphasis> index. The given byte index must be at
+ * the start of a character, it can't be in the middle of a UTF-8
+ * encoded character.
+ *
+ **/
void
gtk_text_iter_set_line_index (GtkTextIter *iter,
gint byte_on_line)
check_invariants (iter);
}
+/**
+ * gtk_text_iter_set_line:
+ * @iter: a #GtkTextIter
+ * @line_number: line number (counted from 0)
+ *
+ * Moves iterator @iter to the start of the line @line_number.
+ *
+ **/
void
gtk_text_iter_set_line (GtkTextIter *iter,
gint line_number)
check_invariants (iter);
}
+/**
+ * gtk_text_iter_set_offset:
+ * @iter: a #GtkTextIter
+ * @char_offset: a character number
+ *
+ * Sets @iter to point to @char_offset. @char_offset counts from the start
+ * of the entire text buffer, starting with 0.
+ *
+ **/
void
-gtk_text_iter_set_offset (GtkTextIter *iter, gint char_index)
+gtk_text_iter_set_offset (GtkTextIter *iter,
+ gint char_offset)
{
GtkTextLine *line;
GtkTextRealIter *real;
check_invariants (iter);
if (real->cached_char_index >= 0 &&
- real->cached_char_index == char_index)
+ real->cached_char_index == char_offset)
return;
line = _gtk_text_btree_get_line_at_char (real->tree,
- char_index,
+ char_offset,
&line_start,
&real_char_index);
check_invariants (iter);
}
+/**
+ * gtk_text_iter_forward_to_end:
+ * @iter: a #GtkTextIter
+ *
+ * Moves @iter forward to the "end iterator," which points one past the last
+ * valid character in the buffer. gtk_text_iter_get_char() called on the
+ * end iterator returns 0, which is convenient for writing loops.
+ *
+ **/
void
-gtk_text_iter_forward_to_end (GtkTextIter *iter)
+gtk_text_iter_forward_to_end (GtkTextIter *iter)
{
GtkTextBuffer *buffer;
GtkTextRealIter *real;
return FALSE;
}
+/**
+ * gtk_text_iter_backward_find_char:
+ * @iter: a #GtkTextIter
+ * @pred: function to be called on each character
+ * @user_data: user data for @pred
+ * @limit: search limit, or %NULL for none
+ *
+ * Same as gtk_text_iter_forward_find_char(), but goes backward from @iter.
+ *
+ * Return value: whether a match was found
+ **/
gboolean
gtk_text_iter_backward_find_char (GtkTextIter *iter,
GtkTextCharPredicate pred,
* @match_end: return location for end of match, or %NULL
* @limit: bound for the search, or %NULL for the end of the buffer
*
- *
+ * Searches forward for @str. Any match is returned as the range @match_start,
+ * @match_end. If you specify @visible_only or @slice, the match may have
+ * invisible text, pixbufs, or child widgets interspersed in @str.
*
* Return value: whether a match was found
**/
* @match_end: return location for end of match, or %NULL
* @limit: location of last possible @match_start, or %NULL for start of buffer
*
- *
+ * Same as gtk_text_iter_forward_search(), but moves backward.
*
* Return value: whether a match was found
**/
* Comparisons
*/
+/**
+ * gtk_text_iter_equal:
+ * @lhs: a #GtkTextIter
+ * @rhs: another #GtkTextIter
+ *
+ * Tests whether two iterators are equal, using the fastest possible
+ * mechanism. This function is very fast; you can expect it to perform
+ * better than e.g. getting the character offset for each iterator and
+ * comparing the offsets yourself. Also, it's a bit faster than
+ * gtk_text_iter_compare().
+ *
+ * Return value: %TRUE if the iterators point to the same place in the buffer
+ **/
gboolean
gtk_text_iter_equal (const GtkTextIter *lhs,
const GtkTextIter *rhs)
}
}
+/**
+ * gtk_text_iter_compare:
+ * @lhs: a #GtkTextIter
+ * @rhs: another #GtkTextIter
+ *
+ * A qsort()-style function that returns negative if @lhs is less than
+ * @rhs, positive if @lhs is greater than @rhs, and 0 if they're equal.
+ * Ordering is in character offset order, i.e. the first character in the buffer
+ * is less than the second character in the buffer.
+ *
+ * Return value: -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
+ **/
gint
-gtk_text_iter_compare (const GtkTextIter *lhs, const GtkTextIter *rhs)
+gtk_text_iter_compare (const GtkTextIter *lhs,
+ const GtkTextIter *rhs)
{
GtkTextRealIter *real_lhs;
GtkTextRealIter *real_rhs;
real_lhs = gtk_text_iter_make_surreal (lhs);
real_rhs = gtk_text_iter_make_surreal (rhs);
- check_invariants (lhs);
- check_invariants (rhs);
-
if (real_lhs == NULL ||
real_rhs == NULL)
return -1; /* why not */
+ check_invariants (lhs);
+ check_invariants (rhs);
+
if (real_lhs->line == real_rhs->line)
{
gint left_index, right_index;
}
}
+/**
+ * gtk_text_iter_in_range:
+ * @iter: a #GtkTextIter
+ * @start: start of range
+ * @end: end of range
+ *
+ * @start and @end must be in order, unlike most text buffer
+ * functions, for efficiency reasons. The function returns %TRUE if
+ * @iter falls in the range [@start, @end).
+ *
+ * Return value: %TRUE if @iter is in the range
+ **/
gboolean
gtk_text_iter_in_range (const GtkTextIter *iter,
const GtkTextIter *start,
gtk_text_iter_compare (iter, end) < 0;
}
+/**
+ * gtk_text_iter_reorder:
+ * @first: a #GtkTextIter
+ * @second: another #GtkTextIter
+ *
+ * Swaps the value of @first and @second if @second comes before
+ * @first in the buffer. That is, ensures that @first and @second are
+ * in sequence. Most text buffer functions that take a range call this
+ * automatically on your behalf, so there's no real reason to call it yourself
+ * in those cases. There are some exceptions, such as gtk_text_iter_in_range(),
+ * that expect a pre-sorted range.
+ *
+ **/
void
gtk_text_iter_reorder (GtkTextIter *first,
GtkTextIter *second)
/* We might as well cache this, since we know it. */
real->cached_line_number = real_line;
- if (real->segment->type == >k_text_char_type &&
- (real->segment->body.chars[real->segment_byte_offset] & 0xc0) == 0x80)
- g_warning ("%s: Incorrect byte offset %d falls in the middle of a UTF-8 "
- "character; this will crash the text buffer. "
- "Byte indexes must refer to the start of a character.",
- G_STRLOC, byte_index);
-
check_invariants (iter);
}
return values;
}
+/**
+ * gtk_text_attributes_copy:
+ * @src: a #GtkTextAttributes to be copied
+ *
+ * Copies @src and returns a new #GtkTextAttributes.
+ *
+ * Return value: a copy of @src
+ **/
GtkTextAttributes*
gtk_text_attributes_copy (GtkTextAttributes *src)
{
* @dest: another #GtkTextAttributes
*
* Copies the values from @src to @dest so that @dest has the same values
- * as @src.
+ * as @src. Frees existing values in @dest.
**/
void
gtk_text_attributes_copy_values (GtkTextAttributes *src,
dest->realized = FALSE;
}
+/**
+ * gtk_text_attributes_ref:
+ * @values: a #GtkTextAttributes
+ *
+ * Increments the reference count on @values.
+ **/
void
gtk_text_attributes_ref (GtkTextAttributes *values)
{
values->refcount += 1;
}
+/**
+ * gtk_text_attributes_unref:
+ * @values: a #GtkTextAttributes
+ *
+ * Decrements the reference count on @values, freeing the structure
+ * if the reference count reaches 0.
+ **/
void
gtk_text_attributes_unref (GtkTextAttributes *values)
{
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#ifndef GTK_DISABLE_DEPRECATED
+
#ifndef __GTKTIPSQUERY_H__
#define __GTKTIPSQUERY_H__
#endif /* __GTKTIPSQUERY_H__ */
+
+#endif /* GTK_DISABLE_DEPRECATED */
--- /dev/null
+/* gtktreesortable.h
+ * Copyright (C) 2001 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __GTK_TREE_SORTABLE_H__
+#define __GTK_TREE_SORTABLE_H__
+
+#include <gtk/gtktreemodel.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define GTK_TYPE_TREE_SORTABLE (gtk_tree_sortable_get_type ())
+#define GTK_TREE_SORTABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TREE_SORTABLE, GtkTreeSortable))
+#define GTK_IS_TREE_SORTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TREE_SORTABLE))
+#define GTK_TREE_SORTABLE_GET_IFACE(obj) ((GtkTreeSortableIface *)g_type_interface_peek (((GTypeInstance *)GTK_TREE_SORTABLE (obj))->g_class, GTK_TYPE_TREE_SORTABLE))
+
+typedef struct _GtkTreeSortable GtkTreeSortable; /* Dummy typedef */
+typedef struct _GtkTreeSortableIface GtkTreeSortableIface;
+
+struct _GtkTreeSortableIface
+{
+ GTypeInterface g_iface;
+
+ /* FIXME think about sorting reverse when the column is clicked
+ * a second time.
+ */
+ gboolean (* column_sortable) (GtkTreeSortable *sortable,
+ gint column);
+ gint (* get_sort_column) (GtkTreeSortable *sortable);
+ void (* set_sort_column) (GtkTreeSortable *sortable,
+ gint column);
+};
+
+
+GType gtk_tree_sortable_get_type (void) G_GNUC_CONST;
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GTK_TREE_SORTABLE_H__ */
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+/*
+ * NOTE this widget is considered too specialized/little-used for
+ * GTK+, and will in the future be moved to some other package. If
+ * your application needs this widget, feel free to use it, as the
+ * widget does work and is useful in some applications; it's just not
+ * of general interest. However, we are not accepting new features for
+ * the widget, and it will eventually move out of the GTK+
+ * distribution.
+ */
+
#ifndef __GTK_VRULER_H__
#define __GTK_VRULER_H__
#endif /* __GTK_VRULER_H__ */
+
}
/**
- * gtk_widget_render_stock_icon:
+ * gtk_widget_render_icon:
* @widget: a #GtkWidget
* @stock_id: a stock ID
* @size: a stock size
* Return value: a new pixbuf, or NULL if the stock ID wasn't known
**/
GdkPixbuf*
-gtk_widget_render_stock_icon (GtkWidget *widget,
- const gchar *stock_id,
- const gchar *size,
- const gchar *detail)
+gtk_widget_render_icon (GtkWidget *widget,
+ const gchar *stock_id,
+ const gchar *size,
+ const gchar *detail)
{
GtkIconSet *icon_set;
GdkPixbuf *retval;
return (parent_window != NULL) ? parent_window : widget->parent->window;
}
-/*****************************************
+/**
* gtk_widget_set_uposition:
+ * @widget: a #GtkWidget
+ * @x: x position
+ * @y: y position
+ *
*
- * arguments:
+ * Sets the position of a widget. The funny "u" in the name comes from
+ * the "user position" hint specified by the X window system, and
+ * exists for legacy reasons. This function doesn't work if a widget
+ * is inside a container; it's only really useful on #GtkWindow.
*
- * results:
- *****************************************/
-
+ * Don't use this function to center dialogs over the main application
+ * window; most window managers will do the centering on your behalf
+ * if you call gtk_window_set_transient_for(), and it's really not
+ * possible to get the centering to work correctly in all cases from
+ * application code.
+ **/
void
gtk_widget_set_uposition (GtkWidget *widget,
gint x,
gtk_widget_size_allocate (widget, &widget->allocation);
}
-/*****************************************
+/**
* gtk_widget_set_usize:
+ * @widget: a #GtkWidget
+ * @width: minimum width, or -1 to unset
+ * @height: minimum height, or -1 to unset
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Sets the minimum size of a widget; that is, the widget's size
+ * request will be @width by @height. You can use this function to
+ * force a widget to be either larger or smaller than it is. The
+ * strange "usize" name dates from the early days of GTK+, and derives
+ * from X Window System terminology. In many cases,
+ * gtk_window_set_default_size() is a better choice for toplevel
+ * windows than this function; setting the default size will still
+ * allow users to shrink the window. Setting the usize will force them
+ * to leave the window at least as large as the usize. When dealing
+ * with window sizes, gtk_window_set_geometry_hints() can be a useful
+ * function as well.
+ *
+ * Note the inherent danger of setting any fixed size - themes,
+ * translations into other languages, different fonts, and user action
+ * can all change the appropriate size for a given widget. So, it's
+ * basically impossible to hardcode a size that will always be
+ * correct.
+ *
+ **/
void
gtk_widget_set_usize (GtkWidget *widget,
gint width,
gtk_widget_queue_resize (widget);
}
-/*****************************************
+/**
* gtk_widget_set_events:
+ * @widget: a #GtkWidget
+ * @events: event mask
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Sets the event mask (see #GdkEventMask) for a widget. The event
+ * mask determines which events a widget will receive. Keep in mind
+ * that different widgets have different default event masks, and by
+ * changing the event mask you may disrupt a widget's functionality,
+ * so be careful. This function must be called while a widget is
+ * unrealized. Consider gtk_widget_add_events() for widgets that are
+ * already realized, or if you want to preserve the existing event
+ * mask. This function can't be used with #GTK_NO_WINDOW widgets;
+ * to get events on those widgets, place them inside a #GtkEventBox
+ * and receive events on the event box.
+ *
+ **/
void
gtk_widget_set_events (GtkWidget *widget,
gint events)
}
}
-/*****************************************
+/**
* gtk_widget_add_events:
+ * @widget: a #GtkWidget
+ * @events: an event mask, see #GdkEventMask
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Adds the events in the bitfield @events to the event mask for
+ * @widget. See gtk_widget_set_events() for details.
+ *
+ **/
void
gtk_widget_add_events (GtkWidget *widget,
gint events)
}
}
-/*****************************************
+/**
* gtk_widget_set_extension_events:
+ * @widget: a #GtkWidget
+ * @mode: bitfield of extension events to receive
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Sets the extension events mask to @mode. See #GdkExtensionMode
+ * and gdk_input_set_extension_events().
+ *
+ **/
void
gtk_widget_set_extension_events (GtkWidget *widget,
GdkExtensionMode mode)
gtk_object_set_data_by_id (GTK_OBJECT (widget), extension_event_key_id, modep);
}
-/*****************************************
+/**
* gtk_widget_get_toplevel:
+ * @widget: a #GtkWidget
+ *
+ * This function returns the topmost widget in the container hierarchy
+ * @widget is a part of. If @widget has no parent widgets, it will be
+ * returned as the topmost widget. No reference will be added to the
+ * returned widget; it should not be unreferenced.
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Note the difference in behavior vs. gtk_widget_get_ancestor();
+ * gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW) would return
+ * %NULL if @widget wasn't inside a toplevel window.
+ *
+ * Return value: the topmost ancestor of @widget, or @widget itself if there's no ancestor
+ **/
GtkWidget*
gtk_widget_get_toplevel (GtkWidget *widget)
{
return widget;
}
-/*****************************************
+/**
* gtk_widget_get_ancestor:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @widget_type: ancestor type
+ *
+ * Gets the first ancestor of @widget with type @widget_type. For example,
+ * gtk_widget_get_ancestor (widget, GTK_TYPE_BOX) gets the first #GtkBox that's
+ * an ancestor of @widget. No reference will be added to the returned widget;
+ * it should not be unreferenced.
+ *
+ * Return value: the ancestor widget, or %NULL if not found
+ **/
GtkWidget*
gtk_widget_get_ancestor (GtkWidget *widget,
GtkType widget_type)
return widget;
}
-/*****************************************
+/**
* gtk_widget_get_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Gets the colormap that will be used to render @widget. No reference will
+ * be added to the returned colormap; it should not be unreferenced.
+ *
+ * Return value: the colormap used by @widget
+ **/
GdkColormap*
gtk_widget_get_colormap (GtkWidget *widget)
{
return gtk_widget_get_default_colormap ();
}
-/*****************************************
+/**
* gtk_widget_get_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Gets the visual that will be used to render @widget.
+ *
+ * Return value: the visual for @widget
+ **/
GdkVisual*
gtk_widget_get_visual (GtkWidget *widget)
{
return gdk_colormap_get_visual (gtk_widget_get_colormap (widget));
}
-/*****************************************
- * gtk_widget_set_colormap:
- * Set the colormap for the widget to the given
- * value. Widget must not have been previously
- * realized. This probably should only be used
- * from an init() function.
- * arguments:
- * widget:
- * colormap:
- * results:
- *****************************************/
+/**
+ * gtk_widget_set_colormap:
+ * @widget: a #GtkWidget
+ * @colormap: a colormap
+ *
+ * Set the colormap for the widget to the given value. Widget must not
+ * have been previously realized. This probably should only be used
+ * from an init() function (i.e. from the constructor for the widget).
+ *
+ **/
void
-gtk_widget_set_colormap (GtkWidget *widget, GdkColormap *colormap)
+gtk_widget_set_colormap (GtkWidget *widget,
+ GdkColormap *colormap)
{
g_return_if_fail (widget != NULL);
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
- g_return_if_fail (colormap != NULL);
+ g_return_if_fail (GDK_IS_COLORMAP (colormap));
- /* FIXME: reference count the colormap.
- */
+ g_object_ref (G_OBJECT (colormap));
- gtk_object_set_data (GTK_OBJECT (widget),
- colormap_key,
- colormap);
+ gtk_object_set_data_full (GTK_OBJECT (widget),
+ colormap_key,
+ colormap,
+ (GtkDestroyNotify) g_object_unref);
}
-/*****************************************
+/**
* gtk_widget_get_events:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Returns the event mask for the widget (a bitfield containing flags
+ * from the #GdkEventMask enumeration). These are the events that the widget
+ * will receive.
+ *
+ * Return value: event mask for @widget
+ **/
gint
gtk_widget_get_events (GtkWidget *widget)
{
return 0;
}
-/*****************************************
+/**
* gtk_widget_get_extension_events:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ *
+ * Retrieves the extension events the widget will receive; see
+ * gdk_input_set_extension_events().
+ *
+ * Return value: extension events for @widget
+ **/
GdkExtensionMode
gtk_widget_get_extension_events (GtkWidget *widget)
{
return 0;
}
-/*****************************************
+/**
* gtk_widget_get_pointer:
+ * @widget: a #GtkWidget
+ * @x: return location for the X coordinate, or %NULL
+ * @y: return location for the Y coordinate, or %NULL
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Obtains the location of the mouse pointer in widget coordinates.
+ * Widget coordinates are a bit odd; for historical reasons, they are
+ * defined as widget->window coordinates for widgets that are not
+ * #GTK_NO_WINDOW widgets, and are relative to widget->allocation.x,
+ * widget->allocation.y for widgets that are #GTK_NO_WINDOW widgets.
+ *
+ **/
void
gtk_widget_get_pointer (GtkWidget *widget,
gint *x,
}
}
-/*****************************************
+/**
* gtk_widget_is_ancestor:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @widget: a #GtkWidget
+ * @ancestor: another #GtkWidget
+ *
+ * Determines whether @widget is somewhere inside @ancestor, possibly with
+ * intermediate containers.
+ *
+ * Return value: %TRUE if @ancestor contains @widget as a child, grandchild, great grandchild, etc.
+ **/
gboolean
gtk_widget_is_ancestor (GtkWidget *widget,
GtkWidget *ancestor)
composite_child_stack--;
}
-/*****************************************
+/**
* gtk_widget_push_colormap:
+ * @cmap: a #GdkColormap
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Pushes @cmap onto a global stack of colormaps; the topmost
+ * colormap on the stack will be used to create all widgets.
+ * Remove @cmap with gtk_widget_pop_colormap(). There's little
+ * reason to use this function.
+ *
+ **/
void
gtk_widget_push_colormap (GdkColormap *cmap)
{
colormap_stack = g_slist_prepend (colormap_stack, cmap);
}
-/*****************************************
+/**
* gtk_widget_pop_colormap:
*
- * arguments:
- *
- * results:
- *****************************************/
-
+ * Removes a colormap pushed with gtk_widget_push_colormap().
+ *
+ **/
void
gtk_widget_pop_colormap (void)
{
}
}
-/*****************************************
+/**
* gtk_widget_set_default_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ * @colormap: a #GdkColormap
+ *
+ * Sets the default colormap to use when creating widgets.
+ * gtk_widget_push_colormap() is a better function to use if
+ * you only want to affect a few widgets, rather than all widgets.
+ *
+ **/
void
gtk_widget_set_default_colormap (GdkColormap *colormap)
{
}
}
-/*****************************************
+/**
* gtk_widget_get_default_colormap:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ *
+ * Obtains the default colormap used to create widgets.
+ *
+ * Return value: default widget colormap
+ **/
GdkColormap*
gtk_widget_get_default_colormap (void)
{
if (!default_colormap)
- default_colormap = gdk_colormap_get_system ();
+ gtk_widget_set_default_colormap (gdk_colormap_get_system ());
return default_colormap;
}
-/*****************************************
+/**
* gtk_widget_get_default_visual:
- *
- * arguments:
- *
- * results:
- *****************************************/
-
+ *
+ * Obtains the visual of the default colormap. Not really useful;
+ * used to be useful before gdk_colormap_get_visual() existed.
+ *
+ * Return value: visual of the default colormap
+ **/
GdkVisual*
gtk_widget_get_default_visual (void)
{
gtk_reset_shapes_recurse (widget, widget->window);
}
+/**
+ * gtk_widget_ref:
+ * @widget: a #GtkWidget
+ *
+ * Adds a reference to a widget. This function is exactly the same
+ * as calling g_object_ref(), and exists mostly for historical
+ * reasons. It can still be convenient to avoid casting a widget
+ * to a #GObject, it saves a small amount of typing.
+ *
+ * Return value: the widget that was referenced
+ **/
GtkWidget*
gtk_widget_ref (GtkWidget *widget)
{
return (GtkWidget*) g_object_ref ((GObject*) widget);
}
+/**
+ * gtk_widget_unref:
+ * @widget: a #GtkWidget
+ *
+ * Inverse of gtk_widget_ref(). Equivalent to g_object_unref().
+ *
+ **/
void
gtk_widget_unref (GtkWidget *widget)
{
g_object_unref ((GObject*) widget);
}
+/**
+ * gtk_widget_path:
+ * @widget: a #GtkWidget
+ * @path_length: location to store length of the path
+ * @path: location to store allocated path string
+ * @path_reversed: location to store allocated reverse path string
+ *
+ * Obtains the full path to @widget. The path is simply the name of a
+ * widget and all its parents in the container hierarchy, separated by
+ * periods. The name of a widget comes from
+ * gtk_widget_get_name(). Paths are used to apply styles to a widget
+ * in gtkrc configuration files. Widget names are the type of the
+ * widget by default (e.g. "GtkButton") or can be set to an
+ * application-specific value with gtk_widget_set_name(). By setting
+ * the name of a widget, you allow users or theme authors to apply
+ * styles to that specific widget in their gtkrc
+ * file. @path_reversed_p fills in the path in reverse order,
+ * i.e. starting with @widget's name instead of starting with the name
+ * of @widget's outermost ancestor.
+ *
+ **/
void
gtk_widget_path (GtkWidget *widget,
guint *path_length_p,
}
}
+/**
+ * gtk_widget_class_path:
+ * @widget: a #GtkWidget
+ * @path_length: location to store the length of the class path
+ * @path: location to store the class path as an allocated string
+ * @path_reversed: location to store the reverse class path as an allocated string
+ *
+ * Same as gtk_widget_path(), but always uses the name of a widget's type,
+ * never uses a custom name set with gtk_widget_set_name().
+ *
+ **/
void
gtk_widget_class_path (GtkWidget *widget,
guint *path_length_p,
gint y,
gint width,
gint height);
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_widget_queue_clear (GtkWidget *widget);
void gtk_widget_queue_clear_area (GtkWidget *widget,
gint x,
gint y,
gint width,
gint height);
+#endif /* GTK_DISABLE_DEPRECATED */
void gtk_widget_queue_resize (GtkWidget *widget);
+#ifndef GTK_DISABLE_DEPRECATED
void gtk_widget_draw (GtkWidget *widget,
GdkRectangle *area);
+#endif /* GTK_DISABLE_DEPRECATED */
void gtk_widget_draw_focus (GtkWidget *widget);
void gtk_widget_draw_default (GtkWidget *widget);
void gtk_widget_size_request (GtkWidget *widget,
PangoLayout *gtk_widget_create_pango_layout (GtkWidget *widget,
const gchar *text);
-GdkPixbuf* gtk_widget_render_stock_icon (GtkWidget *widget,
- const gchar *stock_id,
- const gchar *size,
- const gchar *detail);
+GdkPixbuf *gtk_widget_render_icon (GtkWidget *widget,
+ const gchar *stock_id,
+ const gchar *size,
+ const gchar *detail);
/* handle composite names for GTK_COMPOSITE_CHILD widgets,
* the returned name is newly allocated.
}
}
+/**
+ * gtk_window_new:
+ * @type: type of window
+ *
+ * Creates a new #GtkWindow, which is a toplevel window that can
+ * contain other widgets. Nearly always, the type of the window should
+ * be #GTK_WINDOW_TOPLEVEL. If you're implementing something like a
+ * popup menu from scratch (which is a bad idea, just use #GtkMenu),
+ * you might use #GTK_WINDOW_TOPLEVEL. #GTK_WINDOW_DIALOG is not
+ * useful; dialogs should be of type #GTK_WINDOW_TOPLEVEL. (Probably
+ * you want to use the #GtkDialog widget for dialogs anyway).
+ *
+ * Return value: a new #GtkWindow.
+ **/
GtkWidget*
gtk_window_new (GtkWindowType type)
{
return GTK_WIDGET (window);
}
+/**
+ * gtk_window_set_title:
+ * @window: a #GtkWindow
+ * @title: title of the window
+ *
+ * Sets the title of the #GtkWindow. The title of a window will be displayed in
+ * its title bar; on the X Window System, the title bar is rendered by the
+ * window manager, so exactly how the title appears to users may vary according
+ * to a user's exact configuration. The title should help a user distinguish
+ * this window from other windows they may have open. A good title might
+ * include the application name and current document filename, for example.
+ *
+ **/
void
gtk_window_set_title (GtkWindow *window,
const gchar *title)
}
}
+/**
+ * gtk_window_set_wmclass:
+ * @window: a #GtkWindow
+ * @wmclass_name: window name hint
+ * @wmclass_class: window class hint
+ *
+ * This function sets the X Window System "class" and "name" hints for a window.
+ * According to the ICCCM, you should always set these to the same value for
+ * all windows in an application, and GTK sets them to that value by default,
+ * so calling this function is sort of pointless. However, you may want to
+ * call gtk_window_set_role() on each window in your application, for the
+ * benefit of the session manager. Setting the role allows the window manager
+ * to restore window positions when loading a saved session.
+ *
+ **/
void
gtk_window_set_wmclass (GtkWindow *window,
const gchar *wmclass_name,
g_warning ("shouldn't set wmclass after window is realized!\n");
}
+/**
+ * gtk_window_set_focus:
+ * @window: a #GtkWindow
+ * @focus: widget to be the new focus widget
+ *
+ * If @focus is not the current focus widget, and is focusable, emits
+ * the "set_focus" signal to set @focus as the focus widget for the
+ * window. This function is more or less GTK-internal; to focus an
+ * entry widget or the like, you should use gtk_widget_grab_focus()
+ * instead of this function.
+ *
+ **/
void
gtk_window_set_focus (GtkWindow *window,
GtkWidget *focus)
gtk_signal_emit (GTK_OBJECT (window), window_signals[SET_FOCUS], focus);
}
+/**
+ * gtk_window_set_default:
+ * @window: a #GtkWindow
+ * @default_widget: widget to be the default
+ *
+ * The default widget is the widget that's activated when the user
+ * presses Enter in a dialog (for example). This function tells a
+ * #GtkWindow about the current default widget; it's really a GTK
+ * internal function and you shouldn't need it. Instead, to change the
+ * default widget, first set the #GTK_CAN_DEFAULT flag on the widget
+ * you'd like to make the default using GTK_WIDGET_SET_FLAGS(), then
+ * call gtk_widget_grab_default() to move the default.
+ *
+ **/
void
gtk_window_set_default (GtkWindow *window,
GtkWidget *default_widget)
return FALSE;
}
+/**
+ * gtk_window_set_modal:
+ * @window: a #GtkWindow
+ * @modal: whether the window is modal
+ *
+ * Sets a window modal or non-modal. Modal windows prevent interaction
+ * with other windows in the same application. To keep modal dialogs
+ * on top of main application windows, use
+ * gtk_window_set_transient_for() to make the dialog transient for the
+ * parent; most window managers will then disallow lowering the dialog
+ * below the parent.
+ *
+ *
+ **/
void
gtk_window_set_modal (GtkWindow *window,
gboolean modal)
gtk_grab_remove (GTK_WIDGET (window));
}
+/**
+ * gtk_window_list_toplevels:
+ *
+ * Returns a list of all existing toplevel windows. Each widget
+ * in the list has a reference added to it; to free the
+ * list, first unref each widget in the list, then free the list.
+ *
+ * Return value: list of referenced toplevel widgets
+ **/
GList*
gtk_window_list_toplevels (void)
{
}
}
+/**
+ * gtk_window_set_transient_for:
+ * @window: a #GtkWindow
+ * @parent: parent window
+ *
+ * Dialog windows should be set transient for the main application
+ * window they were spawned from. This allows window managers to
+ * e.g. keep the dialog on top of the main window, or center the
+ * dialog over the main window. gtk_dialog_new_with_buttons() and
+ * other convenience functions in GTK+ will sometimes call
+ * gtk_window_set_transient_for() on yoru behalf.
+ *
+ **/
void
gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent)
return info;
}
+/**
+ * gtk_window_set_geometry_hints:
+ * @window: a #GdkWindow
+ * @geometry_widget: widget the geometry hints will be applied to
+ * @geometry: struct containing geometry information
+ * @geom_mask: mask indicating which struct fields should be paid attention to
+ *
+ * This function sets up hints about how a window can be resized by
+ * the user. You can set a minimum and maximum size; allowed resize
+ * increments (e.g. for xterm, you can only resize by the size of a
+ * character); aspect ratios; and more. See the #GdkGeometry struct.
+ *
+ **/
void
gtk_window_set_geometry_hints (GtkWindow *window,
GtkWidget *geometry_widget,
gtk_widget_queue_resize (GTK_WIDGET (window));
}
+/**
+ * gtk_window_set_default_size:
+ * @window: a #GtkWindow
+ * @width: width in pixels, or -1 to leave the default width unchanged
+ * @height: height in pixels, or -1 to leave the default height unchanged
+ *
+ * Sets the default size of a window. If the window's "natural" size
+ * (its size request) is larger than the default, the default will be
+ * ignored. So the default size is a minimum initial size. Unlike
+ * gtk_widget_set_usize(), which sets a size request for a widget and
+ * thus would keep users from shrinking the window, this function only
+ * sets the initial size, just as if the user had resized the window
+ * themselves. Users can still shrink the window again as they
+ * normally would.
+ *
+ * For more control over a window's initial size and how resizing works,
+ * investigate gtk_window_set_geometry_hints().
+ *
+ **/
void
gtk_window_set_default_size (GtkWindow *window,
gint width,
gtk_statusbar_get_context_id (statusbar, string));
}
-static void
-statusbar_dump_stack (GtkStatusbar *statusbar)
-{
- GSList *list;
-
- for (list = statusbar->messages; list; list = list->next)
- {
- GtkStatusbarMsg *msg;
-
- msg = list->data;
- g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
- msg->context_id,
- msg->message_id,
- msg->text);
- }
-}
-
static void
create_statusbar (void)
{
"signal_after::clicked", statusbar_steal, statusbar,
NULL);
- button = gtk_widget_new (gtk_button_get_type (),
- "label", "dump stack",
- "visible", TRUE,
- "parent", box2,
- NULL);
- g_object_set (G_OBJECT (button),
- "swapped_signal::clicked", statusbar_dump_stack, statusbar,
- NULL);
-
button = gtk_widget_new (gtk_button_get_type (),
"label", "test contexts",
"visible", TRUE,
gtk_statusbar_get_context_id (statusbar, string));
}
-static void
-statusbar_dump_stack (GtkStatusbar *statusbar)
-{
- GSList *list;
-
- for (list = statusbar->messages; list; list = list->next)
- {
- GtkStatusbarMsg *msg;
-
- msg = list->data;
- g_print ("context_id: %d, message_id: %d, status_text: \"%s\"\n",
- msg->context_id,
- msg->message_id,
- msg->text);
- }
-}
-
static void
create_statusbar (void)
{
"signal_after::clicked", statusbar_steal, statusbar,
NULL);
- button = gtk_widget_new (gtk_button_get_type (),
- "label", "dump stack",
- "visible", TRUE,
- "parent", box2,
- NULL);
- g_object_set (G_OBJECT (button),
- "swapped_signal::clicked", statusbar_dump_stack, statusbar,
- NULL);
-
button = gtk_widget_new (gtk_button_get_type (),
"label", "test contexts",
"visible", TRUE,
projects / gtk4.git / commitdiff